{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DEXPEfHQxZ-D"
   },
   "source": [
    "# Hyperbolic Image Embeddings\n",
    "\n",
    "Welcome to our second notebook for the ECCV 2022 Tutorial \"[Hyperbolic Representation Learning for Computer Vision](https://sites.google.com/view/hyperbolic-tutorial-eccv22)\"!\n",
    "\n",
    "\n",
    "**Open notebook:** \n",
    "[![View on Github](https://img.shields.io/static/v1.svg?logo=github&label=Repo&message=View%20On%20Github&color=lightgrey)](https://github.com/MinaGhadimiAtigh/hyperbolic_representation_learning/blob/main/notebooks/2_Hyperbolic_Image_Embeddings.ipynb)\n",
    "[![Open In Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MinaGhadimiAtigh/hyperbolic_representation_learning/blob/main/notebooks/2_Hyperbolic_Image_Embeddings.ipynb)    \n",
    "\n",
    "**Author:** Mina Ghadimi Atigh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8xsgkQqF61Bx"
   },
   "source": [
    "In this tutorial, you will go through [Hyperbolic Image Embeddings](https://openaccess.thecvf.com/content_CVPR_2020/papers/Khrulkov_Hyperbolic_Image_Embeddings_CVPR_2020_paper.pdf), CVPR 2020 paper. The paper argues that hyperbolic spaces with negative curvature might often be more appropriate for learning the embedding of images. It shows that many image classification architectures, in particular the few-shot learning setting, can be easily modified to operate on hyperbolic embeddings, which in many cases also leads to improvements.\n",
    "\n",
    "In this tutorial, you will go through the hyperbolic *Few-shot learning* task. Few-shot learning aims to classify new data given only a few training samples with supervised information. The few-shot learning task is formulated as N-way K-shot, in which N is the number of classes to classify and K is the number of samples given for each class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8qucLFCIGcMy"
   },
   "source": [
    "Let's start with installing and importing libraries. Also, we set a manual seed using `set_seed`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bqsBtgrZOrdq",
    "outputId": "430bce3b-73b3-4e72-bdb8-981246be367f"
   },
   "outputs": [],
   "source": [
    "!wget -q https://raw.githubusercontent.com/leymir/hyperbolic-image-embeddings/6633edbbeffd6d90271f0963852a046c64f407d6/examples/fewshot/networks/convnet.py\n",
    "!pip install -q git+https://github.com/geoopt/geoopt.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "6csDjdMFOYIS"
   },
   "outputs": [],
   "source": [
    "## standard libraries\n",
    "import numpy as np\n",
    "import os\n",
    "import PIL\n",
    "from PIL import Image\n",
    "from PIL import ImageEnhance\n",
    "import random\n",
    "import warnings\n",
    "\n",
    "## Imports for plotting\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "## PyTorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "## PyTorch Torchvision\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "\n",
    "## geoopt for hyperbolic  \n",
    "import geoopt\n",
    "\n",
    "## Neural network downloaded from paper's GitHub\n",
    "from convnet import ConvNet\n",
    "\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_nVWHt_dCQsp",
    "outputId": "131cccd3-de4d-4f07-b497-73a1bf7dc00f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device cpu\n"
     ]
    }
   ],
   "source": [
    "# Function for setting the seed\n",
    "def set_seed(seed):\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.cuda.manual_seed_all(seed)\n",
    "set_seed(42)\n",
    "\n",
    "# Ensure that all operations are deterministic on GPU (if used) for reproducibility\n",
    "torch.backends.cudnn.determinstic = True\n",
    "torch.backends.cudnn.benchmark = False\n",
    "\n",
    "# Fetching the device that will be used throughout this notebook\n",
    "device = torch.device(\"cpu\") if not torch.cuda.is_available() else torch.device(\"cuda:0\")\n",
    "print(\"Using device\", device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6kdB4QmUbyDh"
   },
   "source": [
    "Throughout this tutorial, you will work with _CUB-200-2011_ Dataset. The CUB dataset consists of 11788 images of 200 bird classes. In the experiments, 100 classes are used for training, 50 for validation, and 50 for testing. The code starts with downloading the dataset first. \n",
    "\n",
    "Using the code, you can download the data to the path `data/cub`. Images will be saved in `data/cub/images`. Train, val, and test splits will be saved in `data/cub/split`. Also, there will be a `data/cub/classes.txt` file, containing the names of the 200 classes, which will be used for visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3u5f6fievwuD",
    "outputId": "1e4e65a9-5ea4-450d-cd10-1e359f9a93c1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/content/data/cub/split\n",
      "/content\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output \n",
    "%mkdir data\n",
    "%mkdir data/cub\n",
    "%cd data/cub\n",
    "!wget -q -O tmp.tgz https://data.caltech.edu/records/65de6-vp158/files/CUB_200_2011.tgz?download=1\n",
    "!tar -xzvf tmp.tgz\n",
    "!rm tmp.tgz\n",
    "!rm attributes.txt\n",
    "%mkdir images\n",
    "!mv CUB_200_2011/images/*/*.jpg images\n",
    "!mv CUB_200_2011/classes.txt classes.txt\n",
    "!rm -r CUB_200_2011\n",
    "clear_output()\n",
    "\n",
    "%mkdir split\n",
    "%cd split\n",
    "![ ! -f test.csv ] && wget -q https://raw.githubusercontent.com/leymir/hyperbolic-image-embeddings/master/examples/fewshot/data/cub/split/test.csv\n",
    "![ ! -f val.csv ] && wget -q https://raw.githubusercontent.com/leymir/hyperbolic-image-embeddings/master/examples/fewshot/data/cub/split/val.csv\n",
    "![ ! -f train.csv ] && wget -q https://raw.githubusercontent.com/leymir/hyperbolic-image-embeddings/master/examples/fewshot/data/cub/split/train.csv\n",
    "%cd ../../.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yCJ53D7Md7zg"
   },
   "source": [
    "The next step is to handle data loader functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "QbSYQXtxnHnV"
   },
   "outputs": [],
   "source": [
    "# ROOT to the images and split, data files are available here.\n",
    "ROOT_PATH = os.getcwd()\n",
    "DATA_PATH = os.path.join(ROOT_PATH, \"data/cub/\")\n",
    "IMAGE_PATH = os.path.join(DATA_PATH, \"images\")\n",
    "SPLIT_PATH = os.path.join(DATA_PATH, \"split\")\n",
    "\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "transformtypedict = dict(\n",
    "    Brightness=ImageEnhance.Brightness,\n",
    "    Contrast=ImageEnhance.Contrast,\n",
    "    Sharpness=ImageEnhance.Sharpness,\n",
    "    Color=ImageEnhance.Color,\n",
    ")\n",
    "\n",
    "\n",
    "class ImageJitter(object):\n",
    "    def __init__(self, transformdict):\n",
    "        self.transforms = [(transformtypedict[k], transformdict[k]) for k in transformdict]\n",
    "\n",
    "    def __call__(self, img):\n",
    "        out = img\n",
    "        randtensor = torch.rand(len(self.transforms))\n",
    "        for i, (transformer, alpha) in enumerate(self.transforms):\n",
    "            r = alpha * (randtensor[i] * 2.0 - 1.0) + 1\n",
    "            out = transformer(out).enhance(r).convert(\"RGB\")\n",
    "        return out\n",
    "\n",
    "\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "# This is for the CUB dataset, which does not support the ResNet encoder now\n",
    "# It is notable, we assume the cub images are cropped based on the given bounding boxes\n",
    "# The concept labels are based on the attribute value, which are for further use (and not used in this work)\n",
    "class CUB(Dataset):\n",
    "    def __init__(self, setname):\n",
    "        txt_path = os.path.join(SPLIT_PATH, setname + \".csv\")\n",
    "        lines = [x.strip() for x in open(txt_path, \"r\").readlines()][1:]\n",
    "        data = []\n",
    "        label = []\n",
    "        lb = -1\n",
    "        self.wnids = []\n",
    "\n",
    "        for l in lines:\n",
    "            context = l.split(\",\")\n",
    "            name = context[0]\n",
    "            wnid = context[1]\n",
    "            path = os.path.join(IMAGE_PATH, name)\n",
    "            if wnid not in self.wnids:\n",
    "                self.wnids.append(wnid)\n",
    "                lb += 1\n",
    "\n",
    "            data.append(path)\n",
    "            label.append(lb)\n",
    "\n",
    "        self.data = data\n",
    "        self.label = label\n",
    "        self.num_class = np.unique(np.array(label)).shape[0]\n",
    "\n",
    "        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
    "\n",
    "        if setname == \"train\":\n",
    "            self.transform = transforms.Compose([transforms.RandomResizedCrop(84),\n",
    "                                                 ImageJitter(dict(Brightness=0.4, Contrast=0.4, Color=0.4)),\n",
    "                                                 transforms.RandomHorizontalFlip(),\n",
    "                                                 transforms.ToTensor(),\n",
    "                                                 transforms.Normalize(np.array([0.485, 0.456, 0.406]),\n",
    "                                                                      np.array([0.229, 0.224, 0.225])),\n",
    "                                                 ])\n",
    "\n",
    "        else:\n",
    "            self.transform = transforms.Compose([transforms.Resize(84, interpolation=PIL.Image.BICUBIC),\n",
    "                                                 transforms.CenterCrop(84),\n",
    "                                                 transforms.ToTensor(),\n",
    "                                                 normalize, ])\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        path, label = self.data[i], self.label[i]\n",
    "        x = Image.open(path).convert(\"RGB\")\n",
    "        image = self.transform(Image.open(path).convert(\"RGB\"))\n",
    "        return image, label\n",
    "\n",
    "\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "class CategoriesSampler:\n",
    "    def __init__(self, label, n_batch, n_cls, n_per):\n",
    "        self.n_batch = n_batch\n",
    "        self.n_cls = n_cls\n",
    "        self.n_per = n_per\n",
    "\n",
    "        label = np.array(label)\n",
    "        self.m_ind = []\n",
    "        for i in range(max(label) + 1):\n",
    "            ind = np.argwhere(label == i).reshape(-1)\n",
    "            ind = torch.from_numpy(ind)\n",
    "            self.m_ind.append(ind)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.n_batch\n",
    "\n",
    "    def __iter__(self):\n",
    "        for i_batch in range(self.n_batch):\n",
    "            batch = []\n",
    "            classes = torch.randperm(len(self.m_ind))[: self.n_cls]\n",
    "            for c in classes:\n",
    "                l = self.m_ind[c]\n",
    "                pos = torch.randperm(len(l))[: self.n_per]\n",
    "                batch.append(l[pos])\n",
    "            batch = torch.stack(batch).t().reshape(-1)\n",
    "            yield batch\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SyU1dgz2a0gO"
   },
   "source": [
    "Exctract class names of the CUB dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "gCHUo2XObHRk"
   },
   "outputs": [],
   "source": [
    "classname_file = os.path.join(DATA_PATH, 'classes.txt')\n",
    "class_dict = {}\n",
    "with open(classname_file) as f:\n",
    "    lines = f.readlines()\n",
    "    for i, line in enumerate(lines):\n",
    "        class_num = int(line.split(' ')[0])\n",
    "        class_dict[class_num - 1] = line.split('.')[1].split('\\n')[0].replace('_', ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XIvu81r5VuLk"
   },
   "source": [
    "Before starting the main task, let's check how images from the dataset look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "oSDIoLDxZayh"
   },
   "outputs": [],
   "source": [
    "# define a sample trainset\n",
    "sample_trainset = CUB(\"train\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "FrKGPN02g6vx"
   },
   "outputs": [],
   "source": [
    "# number of images to plot\n",
    "NUM_IMAGES = 4\n",
    "# Index of images to plot\n",
    "indexes = random.sample(range(len(sample_trainset)), NUM_IMAGES)\n",
    "images = [sample_trainset[idx][0] for idx in indexes]\n",
    "labels = [sample_trainset[idx][1] for idx in indexes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 234
    },
    "id": "FyYBjZL8WnaX",
    "outputId": "8a3be94b-853b-4638-aebd-b5c978deab7a"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAADICAYAAADP5KgsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9e7BvW1bf9RlzzrV+j/04z3v79u2+NCGBTigoQiokpEoUtUqtmEggCUIFKonRUiuAhQEqRkv9g1hSKpW2SFJRI0ZIsCVElIimMFSASFDCK5FXQzdN9+2+fc89j73377Uec87hH3POtdZvn31un8sjXHSNOr/z27/1mGs+xhzzOx5zLFFVZppppplmmmmmmWaa6e1I5je6AjPNNNNMM80000wzzfQsmsHqTDPNNNNMM80000xvW5rB6kwzzTTTTDPNNNNMb1uawepMM80000wzzTTTTG9bmsHqTDPNNNNMM80000xvW5rB6kwzzTTTTDPNNNNMb1uawepMM830/xkSkT8hIn//n/Azv1hEPioiWxH53H+Sz35eEpH/TkS+8Te6HjPNNNNMvxKawepMM830XCQiHxaRQwZl5fMtv9H1ehvQfw58laqequpPXD8pib5GRP4fEdmJyKsi8p0i8tn5/N8TkX/92j1fKCKvTn5rvncrIg9F5DtE5PavR2Nuqs9v5ufMNNNMv/lpBqszzTTTW6E/mEFZ+XzVb3SF3gb0HuCn3+T8+4B/B/ga4C7wGcB3A//yW3zO56jqKfBpwB3gP37LNZ1ppplm+k1IM1idaaaZftUkIn9ZRL5r8vubROTvZqviHRH52yLyhog8yX+/e3Lt3xORbxSRH86Ww+8RkXsi8tdF5EpEflREPnVyvWZL5YeylfE/E5EbZZmI/HYR+T4ReSwiPy8iXzo59/tF5GdEZCMiHxORr3tGGUZE/gMR+WUReSAi/72I3BKRhYhsAQv8lIh88IZ7Px3408CXq+r3q2qrqntV/euq+p++9Z4GVb0C/hfgM591jYh8roj8eG7b+4Hl5Nwzx0NE/jzwBcC3TC3nIvK+HOpwJSI/JiJfMCnv94jIP8znXheRb56c+/w8rhci8lMi8oVv9pyZZppppptoBqszzTTTrwX9GeCzc8zoFwB/Cvjjmt7nbIBvJVkgPwU4ANfByZcBXwm8C/itwD/I99wFfhb4j65d/8XA7wZ+F/BFwL92vUIicgJ8H/A3gBfzM/6SiBSQ91eBf1NVz4DPAr7/GW37E/nzz5KsmqfAt2TgeZqv+RxV/a033PvPA6+q6v/9jLLfMonIHeAPAT/yjPM1yXL7baT++07gD08ueeZ4qOq/D/wQY1hDsZz/KPA7c3l/A/hOESkA+H3A+1T1nDR2/2Oux7uA/xX4xnzf1wHfJSIvvMlzZpppppmeohmszjTTTG+Fvjtbycrn3wBQ1T0JbH4z8O3AV6vqq/ncI1X9rmxR3AB/HvhnrpX7rar6QVW9BP434IOq+n+oqieBresbl75JVR+r6keAvwB8+Q11/QPAh1X1W1XV53jS7wL+aD7fA58pIueq+kRVf/wZbf5jwDer6odUdQv8e8CXiYh7jv66B7z2HNc9D/24iFwAD0kg868847rPByrgL6hqr6p/kwQ2gecejyNS1W/P93lV/S+ABfDefLoHfpuI3FfVraoWEP0VwPeq6veqalTV7wP+IfD7f0Wtn2mmmf5/SzNYnWmmmd4K/SFVvT35/NflhKr+X8CHACFb1wBEZC0ifyW70a+AHwRui4idlPv65O/DDb9POaaPTv7+ZeDlG+r6HuD3TsE1CXi+lM//YRJw+mUR+QER+X3PaPPL+RnT5zngHc+4fkqPgHd+kms8CVxOqSKBwCn9LlW9TXLp/2XghybWzev1/Vi2ak/rDDz3eByRiHydiPysiFzmfrwF3M+n/xQpDvfncsjGH8jH3wP80Wv9/0/xyftjpplmmumIZrA600wz/ZqQiPxpksXt48A3TE79GZIV7vdmV/E/XW75VTzulcnfn5KfeZ0+CvzANXB9qqr/NoCq/qiqfhEpROC7mQDsa/RxEvCaPs9zDKifRX8XeLeI/O43ueYjwKdeO/ZbOAbIA6lqD/w3+ZrPuuGS14B3ici0fz9l8vcnG48pyCWHdXwD8KXAnQyYL8v1qvoLqvrlpH78JuBv5hCMjwLfdq3/TyaxukfPmWmmmWZ6Fs1gdaaZZvpVk4h8Bik28StI4QDfICK/M58+I1lHL0TkLk/Hn/5K6OvzRqFXSDvt33/DNX8b+AwR+UoRqfLn80Tkd4hILSJ/TERuZfB3BcRnPOs7gK8Vkd8iIqfAfwK8P4covCmp6i8Afwn4DknpqGoRWYrIl4nIn82XvR/4k3mjkuS+/Frgf7ipzGwB/ZOkPv3QDZf8AxKY/prc5i8Bfs/k/Ccbj9dJsbnT6z3wBuBE5D8Ezif1+YochxqBi3w4ksJB/qCI/IsiYnO7v1DGzXXXnzPTTDPNdCPNYHWmmWZ6K/Q9cpxn9X/KsZvfTooj/akM0P4c8G0isiDFlK5IsZY/Avzvvwb1+J+BHwN+krSJ569evyDHY/4LpI1VHwc+QbL8LfIlXwl8OLvC/y1SiMBN9N+SNiv9IPBLQAN89Vuo69eQNjD9RRKY+yBpg9j35Hr+HeDPkjY9XQLfC/w14L+6Vs5PSco+8AT448AXq+rjG9rdAV9C2hT2GPhXgb81ueSTjcf7gD+SMwX8l8Dfydd8gGTtbTgOw/iXgJ/OdXsf8GWqelDVj5I2v/05EtD9KPD1jOvO9efMNNNMM91IchzWNNNMM8309iYRUeDTVfUXf6PrMtNMM800068/zZbVmWaaaaaZZpppppnetjSD1ZlmmmmmmWaaaaaZ3rY0hwHMNNNMM80000wzzfS2pdmyOtNMM80000wzzTTT25be9A0sH//4x2ez60wzzTTTTDPNNNNMv+708ssv35h/e7aszjTTTDPNNNNMM830tqUZrM4000wzzTTTTDPN9LalNw0DmNJ+v+fDH/owMQQcgjEGV1WoKiEqURUfFWMt1llcVVFVjrqqcM7hnMOIoet7QghoVBSo6gprDXVdY0RQyGVGVCMxBEBRBRVQDCCoCERFYgDSe/80XYkogGKsw1iT3yEoVJXDGEFji8ZAjHs0BkKwIJZ6cYYYh6vqVJ5CCIGuOaAaEQ1Y66gXC1SV9MKWRL2P9D4SVYc2oBCjJ8ZIjKkdy+UK5xzL1QoRYb/d4r2n67rUJ6pY61ierFGg6ztiCPi2QwQk971xFmMd4hyIAIITxaIQPMRIpxAUglgQwRqDGMOidmn8rCWqstvu6LqezdUliLKsK5xVFouIj4FD39H3keYwiQoRBlVHBEQkf6dzRiqMWCorWBFWi4g1StSKqIYuWFRl8oJHQTXifeovH/o0oqoYDAYLMYKP3L1/l/sv3B+q8uqrH+eNh4+el5WH6pc/nvI5iDx9Pn9L/iHXjo/nM7eVN13q0RdlQ+P4XW4WxBiMrbDWUVU11jmqKv92DmNtGntjcn+negyj8tQfkn+9lWie47ZPvoaG3uSj0eu/rj3yqY2celyv4/6YlKjQNwd809BsrugOe6KOc12Z9i1Hvw1gBBZ5vAwyyggknc/XPP37Zk1e8kDLeoFUFeb2XaRagElzrDJKGfoQA7vDlqgRRZ7qkzfrwSzEhqeW/wv/JR6UydmbSK59jVc+L0/oMJb5Di13ah6r8XvaiuPxvunvUndl5NOnav7U8estOTo3qdvTvXKdQ3XCMBPGyYeP568gYhAMxrhhrpZxgCL/DK5y6aY8foKCBEQ8IUa8jwSvBJ/5V9MDU3+ldokp45uqYG1aO9erE6y1mTGVGFtiDOzbQ16PrvfhOMqresXp6nQ49+TJBZcXV8e9k7tt4CoZe7rwwZQfUruHrh/6YeSJp0lEnpYFz6DxuslYlvpN5Mcon65zxXVZ9iyu+mTH9ZO2703bWy6YvP244JWjm68L3lKfp8rOd0/l8VPtk2ul3Dwmkte6o56Wkf+HMZhgHaTIHpn0h+Z7J2MwVF3TPMh8XuZejBFjDO98+WUWy+XTlbtGzw1Wf+mDH+brv/rrOVxtuI1hvV5z78UX6Xxg2zRsO89F41mfnXF6+5z773iBey/e4+V3vMj9u3e5dX6L1XLFx197g6vNlr7rUeCFd95nfbrmlZffyXKxwAfFh8B2t6H3HYfdJSEGfIyoWLxbErEEcUjXI/s9RsCK4GPAx4BRxRA5OT9juT5BxGDEcP/+HdarBd3+I4T+gsP2Z/Ddls1mDXLGS+/5faxO7nD7/ssYY/F9ZHe149Vf/EXUH7Bhw9mt27z0ynsIwdO1DZIH4uFFw4PHBw4h0IZA9KBB2e2f0HV7DocNUQOf/mmfwZ07d/lt730vrnL84x//aS6ePOa1j7xG13V4Hzk5O+fTP/dz6ILntQef4HC14eLjH8cCtbUsVitOzs9w57ep795HrEWs444JnElAN4+JzY5PtHDlYV+f423N2ema5aLmlZfuc7Jecn5+Rtd1/NiP/QyvfeI1fviHfgBL4NPefZdb58qnvqfhSXPJB15/lQevd3zw57uBeaUWZCHgBLFQO0nAtBLECqvqBRbulHecLjhfGt777j2nKzj4+7Rhyccuz+iDA5shQRC6ruPi4jGHds/F1QM0BiQGFiw50TPYH+Bqx7/yR76IL/2KLxsm01/79vfzHe//Wzcz7g1UlhiTf5iMPA15rpk0WU0+ZwwYK1gD1kj+W7CSjhsjOEv6NonXrE2AkpiERMiLSQhJofEhogp91PRAW+MWa9a37nF6docX3/Fuzm/d4cUXX+LWrVvcvXOXk5MTTk5OqBc1dV1jrcVYCxNBABAnIqL0Uf4j98AU0sn4yYtTAeKS/xORtICKpP44euX8tGgdnpEAGkP7Nab2DgLr2icpdJruUwZlUKPy8AM/z5Nf+hC/+CN/n9d+7mdogtKr0qkSVAmkd3t6VSLQ5rqsRViJ8C7nWIiwyAtlSxJ8JyLUIpwYQy3CAliKsDaGCqgmYHD4GDDOUH/me7Av3Wf9z30R9uX3EBdnGGd4YR2pbOqDQ7vnJ37xx2m6lohABImp5+Ow3kgaMVEMGeiKopM3v4okYGRN4kmxVQJGkkDMOI4THh+UKhnG0JS5RurbqDGDxWIIyG2csEso46Mhj1MgqhKiz8plPDqvGomk8SyqRFqcYuLIAtwxSG5zVhHQoQk61mEsYeRPNRMQNb4jN8b0nMQRMlEQ8vzIVyqlvgHpI9IHtAP1inpBY+Z5BNSAGmp3gjU1i+VdjKtxixUiBo0OQXCuplrU3Lp3B7GgtkUkYglYu8MtHnO1bXj0ZMf2MrJ5nAwBIQSC74nBI1gEQ1W5JD9MAq6n69uslid81ns/h9PTM9wKlI5D84Dt/pKf++UP0PU9XbboKCCqCAFFCSjvfddv5/M+4/MG/vjh//NH+f7v/8FRJ8zz1IhJ89zYQSEu8zmqEoJP8iR6RARn0vNiTDxnxAwgPPHFKGdsVrQ1z/UBrD8lTvIzfUgYb1Dmx7NpWOMEsyU5XMos8ntoQ1YwrgPEIuOGasY4mUAj/8SYrzeS2WlUi1SVGDhqrxTjg7G5vzRrwaNMKcA/aJpDJvNcmbuaUXkMI/CTXHYB7cNzJK27SXiX+TEa6nzwyWA2iP50xlUVRmSQ16XPXOWSZNKYDHp9MyhSYiy2WmCMwVqbDH8hYEySMVOZrqqIeoSI+h5iwIeGEDzNoWG5WvNV/+7X8qmf9snfuvzcYDV4z+biksPFFUYMvuuoq5q291zu92z6wJPG04ZIdJbV6Qnr/QldFwgR+j5gTU+Iya7hY2KArvO4rqfreoxYyAwlxiJiCMGnCa2RgNKFnkjAS8T0PdYnKyIhAdU+eCpnqaylaToiZpgkfXdGqCpUDYqjbT3toWWzsSAVJ1d7el+j8iRps8bRtR1RhRCU/tBS1S1t1yEI1tX0fUfXdGy3BzabLW1U+piYNwZlv2vougNd74HIfrentjWXFxe4ynKxfcTF9jGXV0/o2x7fKxGhaVr6GGi6lkNzYLvdYoGFsQnoWIuzNbbeYl2FcY6ljSytol2Hth1dq7ReaLXDO2EdlKgME6btOppDw2a/Y7PdcbnZ4iSy35+wqCNtt6Nptuz3F2w2PU+eNOl+zWC1FnAgTqiq9HHLBFjj6pSoFV1UOhX6eEkfA100tGHJrgu03oGzaeIEQ9e2XOyfcGj3XO4v0RiRGFngCWpg18BuT9v1R7y53+958vjJ87LyAMaKRU1M+jYTFGtIIFUkgVRjBJsBqTWCy+B1BKvp+spajAjOJmGvsQikJMymYDUq9EFRMWAWVEuPtwvULDg5NFTLjrb3dH2g9xEfIj4qLibZJ5oA0GDDmYCMKSxNQrdYxoZeOLLSDceG/8tynxdulWwlEOLU5jgI7bRQlqeOMKjIR5NA2BEIGcFGVBmuK+AkxgRyD9sdlw8fsnn0hM3jC5qYwGqfwarP5fQZuHb5uQHoRbjlHL0IMfN9ttnTmdQOZwyaLQzWGPrBRVB6ZaLg2KSsyMOHRBvpH72Brk7hTk16s+xIUZXOezrfD/OGkNsmglwDqwm8gYpybFk1Ax+KEYySFn1JXoexlsd/Slm0TAarZXyEp8AqpOGTY8YhZJCi2dPlY0A1EqLP4CWB1xgTMCoLVNDRIzaMssYMGAW0KEUZrIphwpzIxAxUYC9lMdcE3mUsOS2QBQAR8uJ+DFaLGqcwgFV88tYkJsyXaVIqAGKfjnemx5qKPpDAar9ExKIhWVytq6naBSYr67iAEcUaxTqP80LbGHyoCLHHa8THSIiRvu/xfZ/mswohZkXUJSBSdR3GOPaHFmtr1osaMSbxm1SE4OlDT+vDZI4rooGhR8KxzOy6ju1mNwCvoiCKFF6zCZhkHgqk8Q8hKyXRI4DLClACc0WRzTyuaY0vHkEpgDKmsYrZylbEUNZl07iqEkMGO2LTNTaXk5+gMVvssiyzRobxTcB5fC7ZG6Uc02hALxWIx5b1XCeNMVscU3s1jryU5HoSugXUAohNYHUQyAWsjoh56CeKrB2MBul6BTQUBX4CVvPTRbKnzaS+Rcxo9ddRmgcNxBgHoat5PUhg1VAUS5MNE85lsBpDAqu+IVXJINZiXcDYAlYjMfihHmWt0RiIGjGaJ5dv0ejxviXEnv2+wYfEU89Dzw1WDemF2l5ARJEYEd/h25b9dsshKG2IrInYqsK5ito4VusT1rfuYLNV4/zWGavTE642O/q+x1lBYqDvOqxJILe2hnpZ03UH+vYJPiiVGvog9N0oDC3KcuFo9wf22w1dnrS37txheXJC8J7t5YZFbXDOEvwdQlyxWN5D45oHHztns+l4cuGSa7F6jHM75JdepaprXnjppeR+OT+n3cHFkweYumO73XNydsad+/d5+OARDy+uePhky8OHjzC2QqwlRiEqhK4ndoFlfYJ1lna740nboLRgldce/wLb7RVX20t8E4l9hXWGvmuJEjFOEesJoUnaFxZxgusWHHZXeIksXE3tam6tHSxtEvTG4iRSCwQiTiJnqyUnpyfcPl2yqAyXlxdsNlv2mwuawxZUMMaxcGtq67HSUGGoFaoIeJCQtXAPdApOUKf0K8GrsFpZbC2cnJ1ya32Hu/cM5+vI6uwN6vqQQJuviVuPNxXRVYDBao2noTEX9LZD6ohEkOgQdag6WCyQlUBVPy/bHkGxgZfzAWOy/pkPHBmp0rzPgnOikJIOJPkykbDT31PcYEZLByoYNchwPxiNqAhqils/CRuxFmsttrIplGWilY/VyBrstfZNnaHlD831vrl3Cjidll9UeR3OyI29OcED06cWeWoyKDN5iYm5/7JQjzEmK1Cx4MSJ9atLlpz940e88UsfZHd5mZXd8RFGBJf7IE4eSz4nIoPl1YhggSXgstW1OHNNPmYmZZTyrneZCoQHb6D7S/qf/Ql085jqsz8fsXdBFzABkCqGiCEmSJWAKILqaGGZDoNeP5BroCrEzALWpAVF8mI00T/StdkqZLJFVgpIPRr+xODJfRfH89dYpIDhAiuMQEyqelJmJKb1IC/CkpUmUTMurulOVGLqh8ninN0YqIxBGlLAQnEZDg2but4ll8HA15LLnYaJDMeVsR+G+x3RKepyqJEKoh40QAhoUPxVQ+w8XX+FKLT+CSIWaxYIkiyKGEQczi05bN+BcRV2scBai6tqjHXYxW0wSu2UuN6hbPG+x/ue/Sa1IXqfQDQ1KgkAF7d/iIFHjx/Rth0vn71IbR3L5cv4uGRVfyB5DEIClMXWXJo7WOyPaJx/MY7yCMmgtqowatIoJ6zHwNeqyTMAgzCVMlsy/wpgNGMFhsO5+00qKpkjh8NFsYkFnBUrJ3FQVKbljz6kAkoZZGhmjASQyQ2QZ0gwyZ0lEGPS2Ir3KKJHeqOxZgTEGfSlE5qqaQSNCYCamOZ7UhhH+XnkkpcU1jeVXAWQGmcBCBKzghCPvB5JEUiKrdGi9qX2J5YfJbIxNgHnLKh77yHmuSKa1sJspR2NGKNrP91LUhxkNFYYckimGFDJ0QKCiA4zvITQqEkKWWqvS2C8WIOfg54brCZNRYbKBeDgA00IHGKg1yQkjTVUdY0xxbQsiFj6vqMPAakcVeVYr1eEUFNXKXayDGJZ+K0xSbuT9G1Ji/iJqeijIn1gYYSVtUiE0HlM9NiQNAXve3zXE7zHYhF1hGwKj8agWhPiGh9O6HzEB9hu94h09E2Dcw4fAnW94OT0jLbrOHQev9kRPvYaZ+d7eq9cXm05dD29T5YGYhLlIVu/kmtTEmOFwKHr6CPIHrCRQ3+g9R29j8nq1nv6ztN1LWoFg0Ej9F2HiWmGSOXxIdB1Hc1+C4s1TpLFwRibrFoKztbUYvCuSoLTCs6AtZqsgkTQQN829G2TF66kLVkLVpKF+nRpOVkGVgtD30Taltw4ycJG0J4sgDKjmwAmIK5HqkisIsEpUftkKXF7NDqCLkAsSCCaFhYdRnpqBfUQG4EcGiIxW55uAEw38uz0u/yX58bwYYwNG7TpyblnUmHV60D2hlqMwlqzASlbKmMBaUMF8vVTDfsGkMooJPXa8eFvnR6RG4BqOV3ApYyq+xQNPn3D0Z8FBE/B8OC2nRwrSEzQZMWUdF2JmcIkAWsKqCXFrYe2o9ttOVxeELqW3I2MPZXLUMXmsjTjGwdYctw2yZJjZBKbymTMn+oWzaDv6XOioF0g7nr6j3+C6BVuv4Qcdujpe8AdW1hl2qfDgpQW92EplwLKns1JMOWOYYmfFC1jHScr7PRqGe6ZgOWjc0xKnv5OwLKUJbkftSxSpI4RYWIbH+8fgWIpeaoKHIOIAYoO1udpbZ7RL3p8ReGi60rUFMQWa9JQq0FGSALGophFjhGNCYxj88NILmoGq5fFR0/TOqRzSJtAqnMLjKtwyxXGGkxl8F0PXhNjxtQ3iW8jGj0a+4zPqgQiTAqRaLsmWbJC6TvB2oqT9SkqyqZtJxDjem9c669skUsgNY6KgebmZ8thNBEp7mRJ81NVMEfyRLlJVg6hKM8as8mFBcZBUXZ0kHvFjT+CutS8wh/j3gdJdTXZSl9ky6QGY2jDtf4p4k+UYpEs01KLMlbuUgbAVhS9hIty1QozlucP60xqh46FHPfE5Ljm1kynzQDWp30/TFZFo6Am83wxCGQAr6XtuQxrHWp0UGzzBB6/S39KmvcDWM0W97RvYuJhm7RlKnsGd83AQIJEGfHkcwJVeCtgFaESizUWb4UD4LueXdfxxHeoONTWuMWCk5MTjLX0vScGRdRwtT3Q7He88MI91icLTs9OEGPwbQeqiRE1xfSBUNUVzjisVIixVFWFsRWuOqHteq42Oxb1gtPTE5p1w3JxgteQBMZ+x3azIXQd0XtY1mhd0Xct3vcINaqGLtyn9Y59+5iu8xy6h4QQuHj0GI2RZV1xfusW7/0dn0nftTzaNBwePObyH/0st27d4qV3voSpFpjFkn3rUQwhRNRHAkJQ6CMENWjX0xPYt5eo7blwNVi4aDb0XU/XK6FT+kOPrRs2V1tsXWGMQ72wu9ghCpWpCWKxpz3bvuFy69Fbd1kZwVBRO0MrgkbDcnmCtUssBi+GpTPUTqlsxDmojGI1cNhccNheEkOEqmJRL1hUAScVp4uKl+9XhCby2h3D5SOleRySRm0VWRRtihSf2BuIEOjwsiNWDVp7+oXH1NBpS9+3aN0T1dJ2p4DFOYuvOuzZBqOwDBa/Fw5vCNFHDvsG50lWtJuA11P8On6KJTUbmrBGjq4r7n8zsaweLfAyllXOK1mzNUlYPgVcZRROAJLdZGLTRUmmSHI3ZstqRgHD99OiNlGJjTJ6M2wfu0ePvm64ctKgskrd8MBSCTm+qzysgGeFpMRMr3nq2XmhyJZBsamMsiky1T1ZErq+o726ZPvgdS5f/Qjdbj+OKccboAbwBFT5oZUIDsGjdAht7pi1McmKKuMYFwt1zGXoYNlLv6fXAsRtQHeB/kd/ElktWF1eEd79LvTlL4HVCFaPu7KAtLKEGxSbdZRxgR3NXJpXy7IwmuFjKBYeHUssBtKk1Q4WTzNdVAAkTkAguSdTaQNQLDpMWbHzNUYtxdIV88JuRCFKnpcBlex8Lmylpb0R0RS4mxy4Ojw9ufevVZMEhk2Opxs8CIVXGOfWOFJpXqQaZ1dtlOH+EaYWcJbiaKNYipUXcRhJIRLuPFmfkTgBX5I8i1Gh69AQ8W0gBGi2j4kBfCuIOIxZ4eoF9eokxbVWq+xqtwRSiIVExYngoyeGjugjqhYrC5yr09oocLV9Qt83BP+uFONioXIV73jhJVbbJY83F/QBikqPBG6eLWCsxdU19AEIhBIWkcc+hOQ2dq64fl0COzb1eaTMj5iB49HgDLxzxHo6fidF1RzhNRNlYLyoI0iVHP9vbZW4KLuN1ZhUh0CugMkg3IJMQgwKH0P2XBWwmowzAzdpCl+SAtgYsRYZn8SYDTrGZf5JYTElHCtk4w2aQD4mh+JI8ZwxyMvpmGg2dKGK5k3hKTQhlVX6aBANZM/gBGtqjjUSidliHpNFdTAGSo5uskEAACAASURBVAovkRSqp6TwTM2xvzoAf0m6mpA2FKJoDgMzNm0kLTUcPG9l8SwGj8mQZ3NWukZtVjoMzqTP8+LV5warSoqzKnFfIUbatuHge7wqxhmqxSLt+s8tD3HsNCFZPlJ8Q6QWg3UuSyAFMclY57NrQNKEsa7GCizXJ1jjUpymq4gYKldR1Qt8n+InQttyOOySC70EglMGIWkTrqpADTEEei94D95r2s3fNwTvORwOxBBpDslt/fjJE4Lv2R0O7LY7Lq6uCEoSQssV9drTNi1915IcjYLUCyrrQJQYLF2zI4aIJ6B4tAuojfThQBd62r4ldBC7FLu5vbyiWi2w6wUJvC8xCItqgRjL4bBnHzq2oePOYoU7u4VF89MNUSzR1kRXI5pqFfuW0HpivwBTsVzWrNYLFjUsa+HWecVqUVHXDuuS39+6wHol3L5lefkdFcbD5YOQFvZACgBEk8XBCqET+ga6JtK6iA+eoD29Jndvpwk4iOkRifj+QFRDUEtUj0pIWQRMBdYgmjY8BPXEqASfFJI3oylQHVxDMLhirltSR0urHBdSzpV7JkCynCzWtwm8GHlOxnlb3KQmL6FFcE0ndqnnaDmTUUuefMoDC1gpzx8snBTMKZMryjowBbgyXj3Fq3qtLyYNTMJbRxw8AaulrtfQ7HE5ZZ24BqSnrqfy3TcNu4sndLsdvu2SbLhWlNzwu8SfDhvmrrX2pprptc80rODoemXYjKIRtPUQoX31E2gUYj/GBk6B9QgFJ7tEJheOvFoWgFFrKCM89Qgc1X/oz+vKjUxKuN5TTODidEnPR1JHotfKlezBEfLmKEkuT5EEn5NVKTLkXihzQMf6FEg81GhigToyJU0OFTCbiino6Ji3rs/BqaV58vMplmQy/13tsM4ipD0GRtKy3Hd9isfNyphxNocrgIaI2IgGxVZK9Iq4tDFFQ0PE43tP9I7Q7XLfWIIkg63vW0Lo6fuWvu9APdEZFt0hW58sKPS0GC9srrZoVFZnK0Qsy/oOba1UrkLp6UKB5XLtM21zAU/JSqbZgjp0UBFxeQAHq1zeYGSMDq7poz6dKnVPgZDJAJR5PzAIjCpHko1SXPfT7CcUEEuKwS7W92Lts2bYSFjiowf+OzJyTCYShfOzVXBgRhi2ZGWUqGGMsR35KFl0EcWQlLghjrTEuF7rBVMUo8ks1ElpY9aEPB91BH3l2aVJMoD/4/vTDuEEDFOfmeFciUU2JqbQBx3blXjCchR5Fkt18+qUFYV0gmRl1RSWoFmJGZ4jTwdUDfW4ziJvQs8NVkEIxuLFoJqCwnfNAa/QAquqZn16yqKusDnlVBuSuzp4jxMQZ9Dg6duOk5M1C2exrkpoXpWY3d0i4H3SaOvFGlfXnN+9nzSCkFJlnZzFFMelgg8RqTY0l3seP3yAMSk7gMEMuxsVoaoXrFZrmkOPD562iRwOka6JdF3a3e99z3a7oe8DbdNztW2oV2tAaZuGzXbD6w/e4GS759D0rE9OOD0/S3E/IWLsAmMr1uszFicnrGKNas+jBwfarsdrj8aOtumIxnPoLui7ns1+TzwIclijYnjjtddYnp5y6533QYXT09s4m8Inds2WJ48fctkdeNTueHG5ZPnCfWqJVAKNsaip8W5FV68xIWA04g9XtH3EHwxq1ty69QLGwvmZpe8Mr7x8Ql0tODldslgGouxxVcedc0PlHAuzpAZe+3BP30PXK+o1bb8WAxb6fYr72S7SRoem7+hizyEGfFQOeQOacR5j4dB0+CBInWckHmMsK3eCsUITlTZ6utAQe09oWxrfvQmXTkCCTL4LGJWnLanFFXGEz/I1Y0ouOSrjyNw6AQ/F0jXKxuP7NY7iqWyqSQK5PNwMZSsJCGhGRmmH5QhYj52tPCX0RufcuIFi2rxRUmTJl11UCajoUYcUsZmsViMIGFLvFItqiSkdTXNHkOsmNVomx6V0EkKzueLxR36Z7cOH9NvdEHt60/03LclWxhjUAWgVATkB9iLJmedJArGI1vJdwKaQNk2WcxGIjaKHjuYffYD6tSfEfXNUNyvpUxbhIHbsjcKXlJ3LEZE4eCETmcEkOALVYhcs8dBTuJn+l7KA5sVTJucGIKmSrUlwVEK25hY+KAthepZFiBmz5HkvigmkRVqUKIKJeQHNpccRMeT6pl6dKnQg134P0GXC2ZqtP1OlaHzGsXd6BEcqJAO1jv2VDcKoJG+LNYbT8zWL9ZKUMyJQLxYYMVw93NI1Pb73KcRqVafZ1dXIsFEthXrFEOgPLb4LNLsdGpQuZxuIfXbXRoMamz5iUDE0hwNd19NXgnMGZx2x7xC1GJfifX3seP0TD9idnvHK+mWqesHZ+hWiLlmvfgFpD3TNIeNNO+H+Y8tqARxJBmYlQsMoMcq4mzEDiBiDmGylk5hCBfLGOtWY+dMMwFYVYrLBpmcO4Cxnhrg2YVWy1yyHSllbpedbmcgRBjAqZMBkkrJknR03/aColjhVSZuU4qjsSombHQChyQCZcXKOnZX7R1H1w7HJ6fScrNgYUYKJWJPSDaZNh2G4yUjOfJFja4sRImTLaAG4MR5Lu/KcQU8r+6ViHNYlLQpizoAkWMqmKzGjESTFngrWhNy2LAXydc5VeV1M2xs1r08mg0wjkjwoWqRNyu4haM4ckepqTZEuRakp1mzN9Zj6MN+cnt+yKgK2Qm0F0aPCEMhuRKiripOTU6yx9E1DvV6xWq8REXzf40MY0p5EjbRtm8zUVY2xlqqq06Lh29QgTUG/y+WCarHk7Ow0TfrdAVWP71IMbNv1bHcXbA5P2IcrOtmTbLsGqza5raRGrEUhpcbygb4PdF1P2/Y0TUPbthwOe4LvCT4JHB8CXd+xvdqiGmmaPV3fUrkKEaHve/a7Ld53WROxVLXiKsX3DbYz+H5PDB3tYU93OBDpUOkJoSeYQOcjfRvoY8o6YLROz7zcEFVZ3z4j9h5rDDF4tleXdKGDCJWtOF2dsF4uWdQVlUmTJcZIHzxelaBC0LwR4LDDScOThx3tYclthMOhodnt6ZsWZyK1VZZOqWwgagN0AzZzDpyz2KrCx5hiHFRT7BWMweVBiS2ECmIwRDW0HoLkdEMRLIojbUDr+xybakCcIjZZpukivmvwfU8f2jRJFxZ117W0Y5BS6jsCoJtAZ55kMoLVayv+CCbKPdfKml46zJPhu9ikrlm1iqCZgjORIe2HsUXITK1i10CpTj96dPy4IjqEJtxEx/kOU8WGmk7NdzqcHtpUAGnKdqDDw6/nkc2YaHhCiUUbrQhDVYdFIXpP6Dt2jx7x+KMfobm6GqoBx+2ZgkkzHGEcr+v9RorTmjZr2mV5DUBUCVKc12An9S7HlCHskBgVU9JzTSpnJLsmJS3RhnHjwbAAT/mxAAfgupVxWnBxmaf7x5bkZTctHmbkotIfR31OGfEJD8HRhqyylqeNcROeHQawMNgAJbKrvygFBSJrOTsqVQkNH43D00vX2Odyk6qiZSxGHhw5NH+XucbY3+U6kzeCpMAK4XR1wu1btzB0GALOrQFHHbe0bcd2d4Fq5Pz8HICrhxcpnVPJ921S+ilbC2IDWIMGRXvFdwHfdPg24ps+ycaQOFjFEGOPSMibYQTFE2JHHzosST6GYDg0e5yzaArGBiNUruLu+T02hysObZsCIIpl+fpEyP1VYhpHNDZaMcv8NXkzX3L/mom7tzCt4Yjpc3lSUN+UTye/k56TLYiTW43E5L0VEJvjGvMzi2JMUYhNkcWZ120xTI1tkrFgRgujDPx5JBsHjSzz+HGjEJLFNInvHHuqdqL4JiAZJWICx2uGTjZWDfg4MsR7M/bFaFHOz9XiycljkgFuCjnQrJiMlnK5zu9l42/aZTq5tsSiStq4qppCLDSnnxoA+NRqm9purM3GE7KCYgalLa0JyUpdchwMWmhZO0s9nw+nAm/FsmoM1EukalJumCx8EbAYlvWK27fuIqFjv9lwfv8eZ7dvY5yhbQ/EPrnmQwxYjWw3G8QYzs7PUt7I01OMNew3DRo9VgRrHYv1muX6hHv379E3HQ/3HSF0HPZ79s2eq+0lm8MTnmwf0HR7GrujUouLFhcXWK0Qs8bWjqDQ+ZhSVrUd+33Dfndgu91xOBzYbq7QmPKFxZAS1LeHlsePHhGC57Df4irHcr3GiqFrGw47j+87FssVy+WK5dqzXEdsY1DpOOw2dG3D9vKCrmkw8QDq6WtPMIFGIl2ItPFAVHCxJrbCkwcP6JqGk1vn4D3OWA6HAxePH2Iqi13VrBcrlqtb3D4753S1pHYWi6Z69z29V3pnaGPaoOQvHiP9BRI61uuKIJG2DVw9ecJ+u6GqPMsqcrpMlk+vG2zssJlZrRNs7bDLJSZ40B40DJOFnJYk9krYQ0CI3hI1cuhBYkxphpScpUDxh4b2oDSNgDHYEweVgdWaeGjp9le03YFDt8NWNW69goU9Ys2nwKqM30lOZVBaJn++3eZrcjjSiA2uT0wzyjtDspRxwzwbXeFpMTjaQjKAPx0qVgQZInn3v8Nl60CWMqR0P8roGp4+MIMI9Lgy5bIxU8lzkA5CdxTUcnQamZRXUreUdChci10tT52GDJSy9YYaDQuF4LuOdrvl8asf5dV//JNs3njwTKB69C3y9LHJ38UaGTjurmJziuR9gxngTMG8kxSTWSy1xbJacruW7VLH9UsuXCs2r+0TQDVVBrKFvVw/YaKhXmXzj+b0RsWKA6PVsiwNNufINGVXdOG1qTKC5PRix2Ohk45WyPGADN6vwV1xfQhFUsxsjh00klMADfGT6VwkzcUx58NY3LDZsMiTsXtSy9SPFYMBtAw8d01TUMpO5RyAMaCiMsHH1ltJO99fOL/Ly+94mRU9lUbgnKg1j893HELDa298iBB7XnnpZQjKL2wamqZJrve8bV4s1OslEFmakp820u0bmo3iLxv6Q5NeEBAUzTGlxYpYOcFVBtWWPih0B4yNOFehCpvdZQICXVLs1SiLaskrL73C48tHPLl4jA9pY++wV+hpYUUseUoNaE41YWzZeJVusDkTibiUT/Yo+kIE04fJnvxyWLJFMSQwTRnkMU4YcuiIlUFeGhVUR762Vo5c6cH7oS8RUgqznOtzAKtPsWbmpOwSH5Q3iowttZcJa2SwPcj4zEuqyZgy8KzJPE9Kx0v6Jr/IKLniQWIyRoSQ+7wAJx1B4wCgRRCTX/7icnsykCwpnpyxefO65pRyOazMyGAZTUvGqAaWtG7GmARYy+Z1FGNyBoaYwvZEAvWizmufo8S+pzkWcx5xl6yxkhRyI8njQk5tF0v/5HVrCp81e2NKarTnpee3rEal7XqavkdiIOSgcFel4PHz0zNWyyXtvmfftiCG9foEK4bo+5RXMmpiLmfp2w7tei69xzlHtVhR1wvEOlSg67YYn5Oe2KS9hRDY7ffsdlseP3qDpm/Ythv2/RVN3NPJnlAdMMEhJKuq0Yp6sWB9cpIS9Oa8dn3O1WnMJFlxziPX+5B28cdACErbpjddqXpELM45rAhODOo90Xt819KgBDq6uKGTmipU9K0n9JGm3dG1PSan6whdJEpErMNFWOgKjOBWJzib6uucY3f5hNh7ms2WvuvQ7B45WZ5gTpaY0zW3z25xdnZKJSn9iW/2dLs97vyduEWF9pI8DvWCSM3l5hG7JkL9IZrG88aD19nvW9anK5z2SNhjzAGrHpNzFiZNV7CrmsWdE0IVaSWizRXabNFOYRdRB2IVs4pYBe8DTRfwLqfhkqIFJu6rTw09Sn+R+lwOgGu5Wm84bBsO+w2dT1kdTFVhnGF0mWfeLPPgOag8f0SK1+49WtwnQl6OjAJZY5cjACd58VcS6DE3lp3EnJi0uBuT0/YYlzI2OIvLb6qSvONy0ExLv5V6aP5Pyo9ph0wRYoaPOoKVmwDs0Y5XirBLjcmbo4cHT9+8M8aplt9jRUpVhnpnAZpx6WhVYKxj13bsL684XF7SXF7g29G1LlwfGzk6d9N3aVMkrZ0+KwyWYwGoJAWqQ7CqQ7o9JYUITEMKio2v1zHsAx1a/My+NaUzcuMHq3MBo6VHJgAje0UpO6g0J8KyWdCbSYtl2LFvji0YOhm/QbG43kv53NAYYRhTxrEqx1NfmOzHIqWmysrIkX10RKOZl5OrNOq4vaV8DfNz6ItsCS9K3oBepz1dcoRca8tgxRkrMi6aUAJayhQCCLHBhw0qp4gsUZYIlpW5hWXNi2ePibGhFkOvKcytz7lmIYXJlLRD1lUsljYZA6PSugXJp1ShGNp9R3voiSFZo4zkF41I2fyXNn+hIXkz1aBR8KGj7Rour67oQ8/J7TUijsrdZlH1LOslXe9pujCZs28iIAd5USTbJCwp5+40JJBT8oYG9UAY9gGkjXdFOZFhMK3Yo8eIgErJwZtDIgaezzybrQMm56oeJ0m24mbFbrAkFgBW5Nc1S+8QliBTbk/HBiXzKeVruHnov1S1CbgqDZJRgpUpNWYQMCSrgUn9NZlzhc9zpQflcjS2lB+J3yW7+421yVKripqYY6Ylg/YcqhET71z3rKUXDChGwkR7IwFkBNU4ZKAo6b7KPEojZYZNW6q533O4pcYkA5CSKUDLcI3tLXNyCC9hOihvSs//UgCN7NuWfduSkyNRY1gtVty5+yKnt25xtl7RHrZc7fdgHOent6k0ELoenxPEik1u5GabXM+H3R4xwtnt28iZgKvRKBw2G9BI38eUuiO/ivNqs+Hy4jGvv/YxOloa9jR6YK8bojmgiz2+r1AsNtYoSxbrJafn5zjr0KD0bU/bpDQ4JoNnl83aPgbarpksup793qfN7waMqamrKoNVwbeC9p4uBrq+RfoOaXvqYHCtIHGFqGN3CPSNIjGrYH1IWkqVXku6jmeIMdTrWzi34PTknKieq4dv0Pcd++0WIw5r6hSndHrO4vyU5e1b3L93jzt3buN2G8JhS7u/otlccf5yZLFaEK3BeMGsTvDS8MaDJ3i/ZXu45HDwvPrRj9K1cO/Fd1LhkLDBuh1CD+ozvhDEgTtdsXzHbfxScE4Ij5XQbNFDRDvApoljbkcqlK4L7JoeMQHjIitjcCbvonewuG3pCLT7gD9AbCO9PeBOHtO2LZvNRX5LkeKWC2xthx2pUxp1yDIx4GgeTA6UBWyaV/X6dTfOoQJMiyZ77YLB26LjjuSn6jXutkkTNkrS+J3D5bRurrI5dVsGrCSeSdhjfK5OAEU6NgI+xp9P9dOz6Ajc5aJTCJkyGAULSIhjLsTSJ8AkN+JYztPPz4BVGXfmTq5r9weuHj1m++gRu0dvEPw0n+L4GcLL3qQtBSclIJoAeEd27TOCSHIbeoRIVsRVR0trsTpfe45nBK435bwtlZCc01fKphBJG+1iXrwk35+mWtoxn/HBoABptqbEvKhZGa1Oqeyy83iMG0yLuh3ql6Du9cV52kuFh/J/cdztnTIkmNz/+Y03GQTYvBUlIkQxCGEAAwrjJqkyuTJfxSHkQMdqlEVeQy5Tx13ZxTKfmSDVs4DVa8rY4IctbRzyDgx8U2ZpqakPO9resXJ3UXs3nRPhRE44McqtW5dEtuw9+BDpe59e+GJSbKZGwFlM5VisFty+e4qqoEHYLw/gFtjFDrOs4MkOzw5aT+wCTpIF3xawmiYYxD61JaZQtr5vOBjDo8ePaLpTVuerBIzNCyzrwMlyjdCkdQzK4D3NljLBqRNOkMyvhU+HmEcxOFdTNlZFzbHLRkhQQiblZk+BcZTsJaPLP0KOd4xDKhnJ+YNzqIFMPB5BsvzLFjmZ1lWGbAEy8I9SFMdUhzInJhvICoDS7M4uipGOZSdWHbMFMPFWDLJXSLPAZLCW0WE0Y3qxEbDK2NeSFyBJAFHQIdSiLEAl/jdaTeAzv6nKFqAoecO6Sfs8bJUzWhiT+zXL2ckQS9DBe2wmEs3k2OkhFWBJTWUKUC3pyzQ9y7oMXYsyIukNcNlCL8Yk2ZH7WnKbBRk2Z5XY1+fEqm8tdZUYgxpDF/oUYGssZrni9N496roihB5jheXJitOzc27fvku7uaTbb9MrxWC0xGQx4epF2skfhK6PiDVE4NDvIAaCOkyz4GqzY7/b0/UpZnW5qNHgOfSRqD19PGCkRWyHlYpKFiTHDqQYDOHhg4d4r7RNR9/3hBhznEtittVqhbWGtm0IIb1dRK1ltVoMbzNyrqKuLJWBhQF6IVSGXpP7vZcDXvfoiUOspTKrBJq1IfhA6AMaFd8cUI0sFjXWGdbrW1hrqao1xjoqAyGmyeGMZbFYULsF69UZq9WSZeVYOMfSOSyScrS2LbLb45uG2LUsKsPpuiaox2lkoz297zl0HU174OD3NI2n8T1RLGZhMDUIHWiHxED0ka6FroeIw1Y1q9M1USqCrTgcnhCe2IExk55lWS/WnJ+eYuMebTo8CjZSLZMU0oUQLFQroW4TEFZRfOMxTthXW/rYE+pI9Ir6SIye6PujQPnMnMO6BMP8KEa8NwVo0zLGr4k7+TlnUpn2BcgWsHeEcLTUdcwvJ3kHq3UOa/PHJLBa8hof1WGCMsrCMj01xHVdrxxPH77e9mK9knKTTs+RUgRpEdRjPOyYqYARzE5BD1xLSyTZPSQ51dV08FJqGt93+dWOMYO0sbDkXROelcKsAKIjhUVTWpogCWCWmFSrxzGsHqXXdN4ArSqtKgfN8dYk0FsW+bLUGoHzvh/SY5WOz9CQIWVVQpWUt1WV7hcYMksMgHPot7xxIV85ZafEb3nm5bg8U6whBRwe1ahUpfDJACcpm2qGU5OFv2QGKDkUR7vmpDbluRlY6JDBfHjo0SilfyOfDWNFDtbIRR8pJRNQW7DrWKcMaqYeAin9Wfqu9HH+v2AOSS5L3ytt0xPXDdgdsCapNQ0psEkhCpvNhu3+gA9h6CsjBltVLJcr7t17J6tFxfnJCqFG44oLfUh78IQq4Kqe1WmyYnW7Dn/oUpxjBBEHOFQsyGiZlfysYNJbgHaHLcYJ6iMpwBPqasH9Oy9wud2wObye4wfjtAczHxqMOILmeNuca7WgtOKiHTY/+4CYSCh9m99kNcozM8x9GZiz5BSVQcdIz5b8QpY8JsXrYN3Rzn8tr+iVEnuc7y8vc7FmALeDt05IVsfMtwmgjinfRvXkWIZJ5p/CS8Pu+WxJlayET18nW/pxAPXDiwEM1lVD+TFvGE37WiavFc7AtHgyStvL27YQyZlNDGI0WS1h8kpXkwxD1qT+tGP6teQJ0xSlp3EY/pJXNeWEL654GV52UMCpMalMm63dg4QsnZXHPfGIpty/ee2R0k9lzI3JCTwCqEUkMIZAjLP+k9Hzx6wKaZOSCK2GVBlTYVYrzl+4T+w7fHvAWGF1esL5rdvcu/MCDw4HNl2flQgZYiwK49aLJcY5fADpImaZ3vy07zYQPD5UqKt5crWhPRzo+j3gWS9rQteiXSBoh497nO2opMPJKRVLjLjEqCoQ4cEnHnB1ucXVaYNU0AgmDbAYx8l6jbOWi8vLFGPU9yBgK5fcsiSwuqwdC6usbIDe4BcO2rSJrNU9B3+J1RpnaxZ6DycLNDb4PtC1PrnGdym04DTAcrng5N7tZLG1VWKWPJBWbMqZv4T18oR7t+/hnKFylmVVscq79nwIaNMQt1v8YY92DcvacHq6IPoDVYzsY4/6ln3bsN3vObSXtI2n8ZrysS4Fu1D4f2l7sydJku2873fcPZZcauvuWS5wL0BIlEkUKTO98EH//5tofJPMCAOuCA7mDmamt6rKysxY3P3owZeIzO4e9MioaKvOyqzICA9fjn9n+w4DoiOEZA0/K/ho8ThM07G92UG7QbdbwsdfGLAULitRg1HLvt9yd3MH8SPxLIxewUU6EWiE2CVu0W4rzJOBJoPVc0BdxLSRKErsUq3xMGWwGqZPwKpcvaalfwkovmSFuwZ8FNfE5Ud8aUld4siky39CL1UENmljVRbXrc3xQ841+cflUr+5jJ5ctlFXNy5eopqdnxkDrtv2W2Bdr37/otjQUhkoA4OS/V8syEXwFwtrvfIK/FCAxLI9XL6mI4aAH2fC7BP1XQHDV8/1pfG4sLyszgu5LT63I2TAGlffnYFp9UyHGDmq8j5GDjEyKMxoqsRGiTZMFrHXV2C1boqsyppmhGpKvGRWDszFU5U+Se9LDa4lYraAsSWxI+2teVMusXl6ea2SvVsVDuKCSvVyPFfoMGG6gvwWO/JVr69+l/KgazC8/s4aMBbwuQYvqU31/TLrattS8kesgLVeXgTJRoqYgcdlmMS6DaWt6Z4i4H3kPMyE7gRNA2xIYPUFGDEkI8Lz0zPPxzPeh+xJAYxgm4bN9oY/fPMnetdw2zpE9sBrJPwTj88fCW1gbieMNXTblrM7M1lLHDxxjpDBaszVgqIWsOQxMRKMZZ7h5fyMdcmiRcYpbdPx3es/IOL46e0vKcN+xSBSR0kMxrq8xq6oADNYSeXO05wI0Sfa1nyk0p1xSQLKmfmVszMXUVi8UEVGaY6pXI1K/rsxLgHQrKiF6FFdr87ctrI3ZnBrxObPS+sW5Vkwq+uvLOrhUqYsSnp+W0KwSkJVXs2GbIMvClZJhjWJYjGaiJWUd5BCCRMfb2KcsPUxCn1qur9d3VMuEsWE9L1k/c3hEzGB3xKjaks8bi6aUPacBEhDVkZy/2evRYwJ/LoMbgsXa1k7phhLitJcpI3EOpZpDtmUi5SVHdEcomEgqslOj/R8sQJ64UvK9G8dv4u6qr4IWNewvbmn3+5xtkkVnoaBbrfl/rvv2Ww2nI8vHJ6f+PjxIze3O/pNn8RXjKixiGto+l2lrwohIn5A9Yw1M0rEWIOfPT//9DPeTwzjCMEnK6Rp6ExP0BNTNpkbVSQYxDeIOkQM0+w5nQbGcWKepxSOYITgQ6XaUVWCjwQfiRGMOO5ubmjbhu12lIuADQAAIABJREFUn4SfDzjrEJ0RjVgNtC6y7RMNuQ/Cxm2xNrJrbtm6LTpsmaYUc102XSPC3asHrDF0NtXg/fj+I+RNUARal4Kox3mmUBeN/UiYQt5tAvdvXvM6QuugdwZzPCLjGTGOtt9j2x7TtEmROJ8I80DwEz5OTDrxjDKKYXYt4ja4bo9peybZMvmG0/E9pzjxNpxTFS51HKYWsR0aA/78RPRnVrYmaqC39ZhmoL/x2E3EBvBqeHlKwseNijgILYQIzjZoA9IncaCzhwZMm4RenJK2XCz0n52eq33okyWgK6PMoqQvYHI1vb84/bOr6ZLzj4slp7ok6qy/fLWdpxAASHHVrsEWsGodzi5hALYE2+f5vTzPCgnrAszrs67g4hePiw2sIN8i5KVyqlbgzwqsZtRTgE+s70tG/Oq8VdsWQbe8FgBbvhf9TJjOEOZFyShtY23NlM8+Y+ml69D98hw1OYr0fEPUmjw3qHIqPzHyMUaeY+SQP1snVF3fa46B+Qv3LFyDS2JHmjVlM7i2HtY+r2O0ntRlzFPxkXoNVZJ7NVcOLNQ+JdFuZWGpV5LF07UA1zK+y/0rWNTLPi/jn26zts7m8dXydKVN+bKZdH99tcsrX9JVXSqiwgJmi6qTBacuq7GUii3Ja4ur4wo8CywxQYYEHjzCyAJ3T8AJGIg68nI683JKSbFGBOcsfd/z7Zvv6Jst82lG3MxLCDQW+vY1xhiaJsUVxkxcKcbR9F0ChtYTx4hIm0CDcXVmqCZlXUUQnwDUOJw5Wcfbdx/Z7jbcvb7BSEPjHujakU3XM84zPo6fCLY8+6qFtVoljSWFjVx/4fOqYY1RLUkzajLLQEkAWu0LkpTzGIVaESzP2XQkOkoteR0xrDw2axlXhcmlIF8J8WKZrHJMlnlazr+YbfX5FhWpnLiAqtWc1NXcgQvgu1o21SocYiRhUINkYv6yXgrKrjm0a32qyGWgBHjWPaiEP5gEGl3TEELA+5D3KqlW77UhIeuGZK0kxavaXEZVSxz3ykNWu7XcPye1FQu4LD1WZbUIYlI1zxInu1wunV9iY78Wrv4OsJobkQcsgdW7BFZdw6DKeRi4ffOGv/rT39BvNgzHFw7Pzzw+PtJvWnb7DWjS9BCD2IZms8M1LYoh+kgMAzBgTEmAMsze8+HnX0AjlhGH0BmLMw2t9ARp6bFEIVcEMYh3iCTBME1zBqsj0zxjc6Cyhpg1xNSZwacfDYoxjtvbhwRWN5sEzmTCGSCmjDljPI2FzcbhgzA4gzQbWgc795qNveMUIvOkKesz0/yICHf3D7RtiwmJhuuXn35imkYGPyMCfZOrdeTJI2Jo2oFhmAjzzDyemWZP223pG8O2cbjTCTueU1xtt8E2PeIa4jzjhzNhHglhZI4jExMHVUaE2fW4dovt9phmw8Qd3jveH254mk/8cBoAg6VBXYM0HRqPhPGwAqt1kqRJ7GaMG9neeNpdgLMwjsLjk2f2SustphOaO0NQwaWSWriuIwbPNL+ABdOmzbYUmKm8o5+dn3yyGZejbPzJ8smnqFS/II8vnou8+OtSoLqfymV0eS1RdEVE1K21yh+DFZdqh1uXgarL5W7NQmVlStWPIhlXja6uttrKnH6zFpif65CVVKzCMWvzGWusu/MSc2oFq8UlVYBQjGvgswKr5emrCysDCpPcSKmMY/puDDNxHNDgM5DLLRGp6+FfO2T1s37EAlZTHHT5LGI0Jbe8qPIcIx9i5H0IvAuBxxg5kyyuv3VoiMxX5xRLppjy3Kl1UiwauV63WfVNcWcvVs7lSdaG6bjaxdOmnN2EFzBufd0MsUVWfysYLl1LVxN4PUUKoIh58ZQWrZWVyNJmXYrHpx4vU1eEwt1YV4eymqQFei7A8lolWay8ZYxLdGKeVyUZsWQFSkyguRCtLmRXOYx1beUppVU8yJhvZoAzSLKuRp14OZ85nMd0Z2NoGsem73nz+ltMtPjnGbUzMZzY9C19m5IpG+dyKfLcj2JTLH7T4PEEEyGaBOYKWNU0qjFTghHSmpnGMyexvH//yDR7bl/tU5VH80DrTmy6HkU55zLFl0dRlmwqCGDImfel9rusT139ciVk87m1/KikeRZJ+2ghbAMyOFnPues2KWisCWcxxgowlcVyWpPtihC+mD+LbFnTYunq/8vfynfWgLV8QJVj63jXZETMFkcp7S4PRV47i/BVhRADYnICXfaaoSnp3OREJi0hJRUuy+oesoQkCKvM/6RwWNfQth3TnJLZi9EoueNXcerKZWKVJLBqc4WyIk9KmMdaepcVV6zyiwcrh3mwfi+5WqNkC3LZE3RZb8VQ8ZVo9XeBVSNC13Zsb3e0bcemaWltCqzu+i2vv/mW1w9veH3zwPn5wD/+/Cshem5ub7h7eODu1T1d12GM5Oz4CXWGtu3YNj0IvLw9ooykUnUWkQZRSxiTpTWalOwV1TMOM/PgSbS22Wqrhji1hCAYlzr18Hzg+fnIxw+PDMPIZrvBZSqOGCPeB/ycihcA3Ny8wrqG+1dvaBpH3znmaeIwTsw+cDyekd6ybRzT7Hk5zgxT0p7UW9AOmXtk7tHpTJxmbm9uYHfDPMxojDQumc+f3n9gGgZeXl4IwVOQ0CyhbliJvFfRcSR6z+Q9wzyyH0emqIkj9uWZ5vSCPZ8IjUMbx+gD9jxyOp04H184DY+cxkcmDcwRzi8z4yD4YcY4yzff/A13N7d0D3eE8yOH45Gn+T1P4wEJFhME04HdRsbzwHh4IsxJa++2G9quTW5sZ4GJYXwkMKE2Ytq0Rs5n5fQS8b8ETCPc/LHB2S1/+v7fYL/p6f64Yzg88uuPf4+2M2xmRhs5SophixeuobriUpxe3sQXHTkf10AL6iIqsq7iIdVKgHwB8go4zdJjDYTqUUFwiVktliZZcY2uNPhMAWKyoGmaNltYl9hVk908iW9wkc8g2Xq7AoYsXoIEPBbh+ekDfQ70lQe4BJgJf64tcFDiSGMO6yFb1ErJv0rjdQXVL9ogC5CKUfHnM+PzM+//8R/48T//nzz/+GM22l9uLb8HrH7uKHDFA7MmeTIB5wxUP8bIISoHjZw10cP7fwWofulGFZLF5AKsaRd5LFN+mdR5whrGFatn2RDrHMpnFKLunHkcc5W4au3P4FUuG4RW0LZkw6cxK+Agh3xoPa32auEjWOBwrC7HEu8KusrnKRfIsLJaWjN4Ls8UVw76tUt2BdQ1z8NF6ctJemXNl3OrSV2zPMgn2GJiLjetC3bBPNZgG8NkD5zkQKsPWGICsLphIjJoIKiFWsnL0NDhtIe5JcSZ0/SWrjVs2gZjZmJ8Zh5fOB7yvkcZ7ww8sLjOYQX84BM1UQwk0LwoMZLnUkTwfmKaB47DM7YV/AiuEYxTtps9f/tXf8f7j+84n/8b9kpjVbKL2hqcaRa5mT04RbSU/kvURAWU5mQg1UsP0oXYyGBJbY3LLyNZ3fVlfsoi2DQ3RGyJ608ez8wLtJLXJsd2LhWr0m1licMUkwnqU8iCxpKhn1lY1NbnrJn3a3Bap5LURMAS1ypXBoGyhhZe4UWZMtZkmW6zcspi6VwBW7E23c/k9WtXvLB5vqfGJ6DatG2+llbrqgkxY6fcUTbke4UUh28N1hqaHH5ZgHK5dDGoVbkccjJcGVxRXK6+Ufaa2v4cN1us6HX/KZbX4vnI7xPl1W9J6svjdyRYUcn/93cPOGvprMPZpFm1XU/fN9zd3nG73fPj23f89MMPvPr2DXcPd+xubtjf3mY6hcg0DZyGI7briDGwIY3z6eURZaK/sYhrERwohNmnBeYk1XL2M9M048eQEw/aLDQNMbhUCrRJVqnD4cRwnjgcjszTjHMlLiPFgoQQU6WtnPm63d7QdD3723saZ2kbYZATz6TQgcEPtKYj7lrmoJwHz+RzjhEG0QbxLWbuYD4TfeBmf0vbdMznkeADk5+Z54nD8xPD6cz5dELRzG9mkik/KZpp4jkheM8cImP0nPzMefLMMdVQn84Qz2fccAZ3A9YyhYCMUyp6MJw5jweG+cCsgVlhPHnGM8gUMGq4v/+e27sHmrt7cDuO7leOBI6zg1mwU8qQ7prINE5M5yMhl5ds+47dzS5TLyWO2WmeCTqhJmIaMFGYBuX0HHn51Sfy/86y3zf86fu/Y+P23DW3PL//menxh1QjuVVOJhBFc9WswHXOtax/+SymKAtrtSiK5QhylnP+ulCJ6z+3Bipg/dKhS7JOsQjUTVzWDUybtjEW6yxN0+CaJllVS4JVjhsqi3+tjZYNZe2kXxKOFlC5vF9uewlF1+fI6rV2U369EmJrgKOLu68oErX6yhVQLhaKKttXbZuHkdOHDzz9+M/88l/+b4anp4VLk0/b/SX4KKuf66NcJ5IAqCe5/g9R+RCTFfV9jAyqDP9fAOr1/TQBNC0u+XXYadkfgUoTVTZsAGK1RFaARt3SF3dg/ozs/k8juIoIu+gIyeexUtDWgDWDVZYxWlP8FohbqtWEi017iQNUWc7W1b2XZ0vzX4mVR3V5wjX4ZJnKudEL4RAVZCkki2TpmNXfJBOUF5dByljmol31/FycY5YDZyYcz1hcbmvHxMiUra9KIkI3IjhpsbSobwhhYvAfME2Hc68wJhDjkXk+MZwGZj9fzmcxGAumdWAs0ady34WzElNGI5GEaQZgPnjET5ymI+3UEqYEBI2Dvuv5vvtrYgj89Ms/c02gksY4JXglOqplfGufV1knqzCkDDRMBkm1rnxcKQ2l79NzFbBahGKiOiqKWAaQK2tujYPNi0MlZtldxikXKJDEr7rQSSW5bYq10LhE+RXn/H2tYriQ3WvMhgRzFapVwwh0AVjrPpLVfC3AM6kSq2TS1CHWGDQDVcmu/IvYfs1BO7bQMqa/2WqdWLUpX1eMzUlciW7TlP6QmKirSD4CjYraSFRJ6yAXeGjaFte0xFyBrMDrmqCb11zitFWKH0okYay01lnFQ+e+z3G5InqZ11fWYn0EqRbirz2+Gqwaa9nst6gxdF2DnybePX4AJ3zf/g2NCK0kl/Pjh3c4Z/n2r77n9m7Pbr8hzCeePsyYRkEih/GR83imHTYQAo/nEVEY5gEximl6tGlpLIg4Xr16yBQ/Bj8MnJ8+pEEPAY0GiVuc9FhRLC3WNFjJoQCkrMr7h1eIsWz7HmsM43BiioEQPN77pMGJoe83dJueru8QUcbxzDjPxKxhGtOB69B2Q7SK1wnTNmw2bQ4KD2y2N+xvbrEEps5yfBk4PR9puh7bOF69foNq5Pn9B1QD45iCnkVMyk4ORetMWZFhzmAhRGzjuN1u+Oabb/jjn/6W3sw0MqMv7/HnE9JPiAae/uVHeHrm/X/7fzg/v+clPnMKA8/nE8/DiSkEorHc3G/Zv7qhv7mn3d4QjU2E/nllO2cyRdGIxjNhfCbMZ2IIiIC1jld3D3z73bds9hvavkH3T8hmwMqMep9mqYXmxtDMSvxnhSCEnxu67+74D//xP7Dd3NBYx9vO8fM/3HKenjk8HziHyDSnqlyzXyzg66MKyfI7n4KWy8XCp8Bz2RtZrakLeo0KEsq1yi8rTVMkJ3cYUmUQSfE7Kf2lCL80tikEoMG5lsY1NNmyWkB/2kykhgIUF13VdUuODAVxKCWL9hpqpRjGRRhWwJKfoThTizFP12YTXcelLiC1flYSJ1niWNdjQRbmrKrm1O0jRqL3HH7+F378z/+Jt//wD5w/fGSephofuk7uKtddx3muN//LZ879vGpL0JQkddSU5f8xW1Tfx8iUQWr4zLV+/5FbqSa76KVCyfJT+mrdXwrZrV7cqAUxpo2DupFmS5vmTF7V1fVXIO5iGy6gjWW+JBKtZIWKq/HNlWiiruZ3XTjpapFlzKvqVKys9blK+YHMGboaLSnIVleXzX1SN+f8rAsyyMCfxVqnqqWY0HItIzStY3ezwTXQ9zCOgeNxwo/KPOZnjEUpyHnjmZw+agKkZEZeQejYoAxsmneERhj0iLWWfr+h7RxBX4Az2x62/YZN8yemKfLr4zsenx8Z5jNz8BQWedUlfNMYME4xzmGjEHRAw6J4FK+bSERIltfgZ8bhxNE4fn37C7v9htff3ZEYBXZ07R1vHt6w3+4vZ2aWayUeviTfVaO0uZwzF7HmRQunUKdlCjJdRry012IXnSOmMuyaS9IW4ZX21NWaqGb9PCbGXYJ7UrGCtnXLHKmKtFRZFkpBFZJFuF5RlZIYVZLwFtUuv89x4BeUX7KcaTMgLNb9qsynIGYqLVPu40T1lNdMzOaWnHEv1UJsqWEFsCR5WZfndMjrMCYjh7FJEY65v7Ws0CQzImQg70AsajUbRHISrzVpPKJm7tvFyGDX4L08X7ZaQ+JPX/q+dk45+WJvShbxzAKQg5TWgP9rj6+3rBqh7XvmqDTOMg2B5+eP7O/uMM7ijKETg8bA8XigaRpuH+7Y7To2fUPwI/N0wvYKVhnmI4MfmacBGyFM6cGCBowztHOLSEMIgmss+90+mcmdYzCW8fkpUVTECMGAbyuVReWpK0A1w4Ttfk/b9XQmWVb9PKRBzYsnBMVaaNsmaR6tS3We/Yz3IQkuYxHTILZFbUuUiYBJQKPf4P2M956229Bvttgw4E3k6eMLx5eBfdNirUu8siJ0255xPGXqiEgJ9E8uIEFsFsQ56DyGSNu1dJstt7d3vPnmG3R8genArEqYRmz0oIHTx/f4x2cOb3/mfHzi3J4ZZeI8TZz9RNAAYum2XRK2my226zNAkKr5WiMEo6h4YhwzUJ1ShZK8qHbbHa/uX3HzcEO36zgaZTZpoibuwfRodiO4XlAPOkJ4dLibDX96/Sd2+xuCCYTzgb7dME5nxlNgisocEgeuD6kPLo5rpFJA65WcuVga10D1yzO/YAM+d/pqiVZtOe2nSWtfLJA5xUSLyyW1SIzDmOL2d6vEqgxSJbve6kYllze9uG8Bq5cdshby64fQVUcVkFMEul6cusDEBZDmn7iiUyng9era6zumlyXGKYHiSJxmzh8feffnf+T5X35iennJOfBleBeAvVYc+PTqnxxrY2aCTome6qzKQZV3IfCsyvvw3weiXh4JsBab6acqFKw7vWymadoUoFosoQXo2YsrVGtldWEW0Jjh8drd/UkvpTWuhZZsNa7pdyGFKRSC8ZJQA6WK4eL+XxILq8JU8OYKGF9A6Ope/fx8S3P2SuXMVrzSj0ZTW0IOKyibt4jgGsf2dkvfw80NvBynVLlPItELkZCfsbSzbPwG1RwoT97wsTS0RNnQug2Nm5jnM9YY2k2Lc5YYz4iMdK3QNR2te81wPvB8eM/xfGTyE0GVa6UxgdU0FsYasEIQAxLysxQlpazSVLRGQmCeJ4bhzNPTEyqRV3qLaDLQtM2O2/0dfbu5GPWaCFvomYqVk2KNN0uHlBkmZZpKXsPXqW6r2bUCw1VtyfMqhnDBQGCKMC7jvGY1ydcQ1pRNiRrJWQsiObZ1PWHImKmwRSzehrpGMtAu87HMl2XeLYEuy4rJMlsKCJQVWI0Z9KU9vPRt4Y41VlMsrmoNS5BScKHQX9XCBivAnONDUbC5DGpUX6mlNJrE6SoLYF5MGQk4F7YENWBtk8MRzBI6t/Iylj52JluedemDEoqRLKq5QEFNYpSLvio0h+T1lHhXS6+uFN7fAVi/Gqw6Z7m92zPNI7/88i+M08gUPVjLbnfDpm3Zdx0heEKYGc9nXp6fcGFPpxuGaWL0gTAEoo2c/AHPxHl4xGvH+WVGo6R40ralnZMVwU8Ba2HT9ZhSinJyOJNitSgxc0hyGWpIWb6Acz04Ybfdsem3aWLNM2c/EEPgw/uPnM9nxvGEnyf8PBKjZc7W3dNL6h5VcF3L/ptvkDBhphM+BD78emAY5lSJxTX0fc80JxfEbtNzd7Nhf/cGp3c8P79wHka++e479ncP3D08EEPg5uaGMI2cng/Ms8+bVIphEklQG0mLoCRUOOe4udlze3fDw8MdcTDoIByedpzbDRBRPzAeDgyTJ7y8x8wD201H27R8zwO3c8dOZjS23G4fuLnZM44TPh5TGdvntzy//4Xz9IjMAXwkRMUPA8PxA8OHA+H9EzrO4D1Pjx9pncW03+K2t5h2oGlHxCQ3UQhKiNDvDSEqzYMhni2uTeBdfUoaezwf+PX9R/7l/ZHD8cyH50AQxRtJ/OSBFGj4W0fd14r7nLow0ssSUXQBRL+EgmT5PgVkld/La8WpORYtgzqbaUs0t6VqoTm+xzYNtmlzGECpYuVomqb+WGdWm0tqXCyumhUYrglKRUqs8GLlLVyhgNoHK9G87oKFYi4lRcayiRTXv2qNWa3Z40VgXfVhsdZWXBULPyiMxyPPP/7Eu//6Z97++e8Znw8ri+MlvPrc0JSj0FMXDtv6vjwPCfzOmvhTH3OW/8cYr/hR/zsdud8zc3r6rMyTTN8STAaDrFKKag3HLNOKVdUknlOVSEylGljIDJfOKBtvPa60lfX2m6zWiwU0ZWQnS+tCR7ZYtjWTm6/0svRawj/yJ4XsvTxLtaxSbbPlaet8UZaf5M5dQEV1w65wXqR4GcL68Ws5ZUgxd9PLRBMitg3cNpH9t8rkhXE2nI7C6ahMQ2SeEhvMeArcda/Y0+H4BrhlUZuOiAz02xbPlnE+46yhcw3WKlP8SOcM9zdvaJvXCDsCJ86cmZnz6EANF8qhGyB4FCMRaR3WCg0bom/RMBYEnnpSIhAIcU4yZjozKjy9vEdM4Pz0mqZztFtH393x3Zv/mX3XfnGarjy/yxrVy1VXeEuXQb+Ep5JD6lLMtLLYaDPQLoB0tWLLuJpSdlPWc0yTO3vBbtQQqAwAY/bSLLp5ehNrZHghsi/k80IpsWskV60MQskLyaemtpkl7CHJrqJYFMWmWIxzvLka1CgSchx25ifVsscgYJOcTKWbbe09UwwRZVXUrk/zO/gCXsvcsaCZzSgbsARBTcreMdamVRWXvi6dWBgWZLLEoHntL8mtcgEiBWtIiltM9y+0imVsU7vN0lzV1XitPye5DmIC6GRLbbnM1xxfb1kVQ9u2iBFeXg7poSWVlWvbjq7v6TcbxnHAD4F5njm/vDBvLGxSgtI4e+YY8CYyxxGVmXkeiDFwOI4pPtM5MCaBm6A5jjRZc61LpuvJ2jzBoQq/ggSKZaBaeYS2yRRW05SI+6cJP8+czmfO5xN+ngkh/ajGRO9kYBqGOjDGNfTbLTpNqEbidOZ0HJiDolJiDx02WyDa1rHpGl5tGzY20ncNxgq7/Q239/f02x1hnmi7jq5tsdamQgSFGqbwm0nWNItVTRVrDX3fs91s2G43RPEEmRnajqHJQinO+NMz02lAxyOigdZscY3ljh1tYxD1RG3ZbfZs+w0+BHwcORxfeHk5MBwP+HDCxJCrqSjBz8xDwJ9OxOMp7WJRGU5nnh8fefh+zz50iJsw7YyYuGx2Ck0ntBuD2xkCBuMSV170M9MoHF5eOLy88HQcOZ5mzkNMNG1NBqo+ye3LyXn59kLortbDem1cvP+tNSPXvyzb7EqO1s/Sq2Zvd7Fy5k9LJZnSuKw1G2uXH2NyELxdWAEK36osbdXVDT8BDuU/XYRcAUOXnbTA1XWHXQCdFRAu7uG6xlh//q+DPS33Ku9zH/lx5OXDe47v3/Hy/lfi5D8LVH/rWI+OWb2yei1wI6DMJHf/OSaKqv8/bKqlQWmerOLqWD2XLicu41dkGXUwFc2x1EUd0pWndOlZzeN3FYG3es33l9XYUSEjJSThIqRjrTjUzS1frygzxcaa27NYZK4/L9AsryNZ2lMfeRWrU+RezfKvazrTJK37qzxhXeCgQQmDJ9qIzDNNR+J21sSaalyxYidPiKrifcTpll72qG6BjsTA64EJkYmmbWmDr0mQzliMCczzGaRl07/CmQ1Ii4olSIq7l8+MRQKuksMBFOdy2M/cAIaoPsu8JQUvKRWBqJJkshiG8cQwdIznGRGh3VqapqdpejpTyll85igCo2iUtVwYS5+v5MUyo5a4YTIo05isbyVaoM7N9bNXubu4wBdPS342NHlGyx+QbOwt3iVZKcirHtVlLheQXLxZpspBrZymF/R3sjSuVI8CyQlPmo3PUtu/gNW8AmJZo9cyNN9fWdYNpbuLEYL6POVzJM+LvGYK0X65dggrWaxak1uNSCp7XMetjFXaiINETPYi1VWzkt/V+ikZcIqSyPwLW8RqYy39VRRyE6lFR8pYxXR+XIHgYjj6PcdXg9VpHPjxn3/g+eXI/Tffstvt+e6777m/f40zwnA6cvz4kQ8f3vHu7c+JCgbD/d09trvD6ZnGTEQzoTKzaRxIwI4RZs8wDfhZsY1jjp5+uk2gNcbMHZa0SEMi9O83W+Z5ou1abEzJO5TNNEs9IyZVdsob7DAM+NkzjRM+eFQFEcfkR8bpzDAcUeAcJrqu541ErLUgSr+/4fXdd/hp4iyR83PgZfR0Xcftfot1Fu8njEDXNWz6DbvNlm070ptAa8EZ8H5kGs+0bUMMnhhDotGJmX+ulDeroEQpWasqQjSG7f6GP/zVX/Pmm++4v3vFaIVJPP3tPX5Mcbg+eKwkvlZndqgobn8PXYPgUCs8/Pv/CdfsmOOOgEvMAtORx8M7Tsd3xPiIs0c2+wE/w+gMpwM8T4L4kIL/8nF4eWEYB3Q/8mHuedN4dl2kUY9RMLkUcWt2xNawfXOH31uUOw7O8J/+/v8C4P3Tez6+/5WX+RHdTtz8oUElidnwIswfwTh7MTcTJ3LeQFU/AZ/r/rz2Oshq8dfvrM5ZL8k1yK0xkHWzz+NVNtzsJklKnUnVMyUJXIPFZRYA2/S4pqu0Va5JP7ZxtaqVsw7nmhy8XoRlhg96qaAt8YKpUQKZ97ByMS9AQVfpLitFtyZqrQBqjWVkuc+l9WVRllMcpdZ7pH6+Fk1JuPoBb4EJAAAgAElEQVTgOX78wM9//1/4+Je/4DNbRrnyMobL9+PqmuurVpAqVdzWa1RAApfjdfX+9xwCdJJq43jVVcHJcnHBqEmgKkRUwIsiJQ9IdRV1ufqaFiqoSJSAagqIMJoIxtMcVcT4VC4yP3kpvVpA3zoho/womhNWig2rwNOcBEZ2scsCJtOyWsOIMsl1me81tjaUPy3WuJUr2dTZd/nMRgtUye3MQMasKhDF+h3zyXgppWLWJVlciJHjMDLOyvEYcA7aVnAtNL1grfLqDvwOfBRSCakZ445AQOWAkrPacSjfYM2OP756xWk48fJ0Agk0bY8w4wclzjPn8ZnWbXEt3PT3/Nvv/z0/v/uB08sz+Fx6XFO/FtZe1fTcQQLRaGIlMSneMJ3sk3wzWQYYRSRVcAxBmMYTR+t4+/5XbsINm/tvvggIKv9mLptKnlMXqoRItTAWJaWWG9VLy3uRJYmSKY1IpU4iTwOrSEgUiEZMNj7ZFZl9SipOIXZQ6d2sucD2iSkh4qcpyQBrrx/vYmZUz9FqQyhJXWJlRQqxSIJF3KyVwPVVufg8FeMAWxZ3kbHrPs/rJsRq40kYJIPhWEF6+l5cPa9Iyh1h7c0KKVSwWo1zWIBeyNpIyaNYknXzuBbGgPLAtS1kPCkYK5lrO7OMZIqzWniE/F4shcEEkxXJGBJtlcQFgK9npKYEPblezF84vhqshhg5n45477l/9Zr7+wf+8Ic/0nU9qoF5mji/HHl6/MjbX39h023ZtFuCGsR2GBcSaEGxohiXKS1mJYrifWCeI9OcKnv44HFhqSucknkkBRuLrDbzzFFmchJQDYjWvMhIZRtDzBZVz+znpJVkl0LQwBxmpjAlt5GPeD9zM9ykuBijNH2XCJ3VMTYNGMPsI11vaLs2begh1HiQxCLQ4tyME0n0Mqr4eWKaBvzcoyEQYsiTr+oieQKUufYpTZNrWm5ubtnt9nT9Bp1PxKml6Te47Q5/PqLe10lpbQtGcG2PtB1qHLZr+bs//q+0/Q2HQTiPM395+w7vJ8YxZa7CGWdHdn1gtoKJMB9BPGnFrcDKNE1M88TjIRL6hpvZssnJJVIJwg1WepxxNFsLxqChZQD+8vYXYgg8Pr3jeHhkjiPWRbp7szD1RfAH+WwGYTWss1oOcvW6/rwAtxWQ/dLxRYHPYpSo+zcrAZXnrhSyaxYwm2KfU8aqKRWrrKkW1mJRXf98ykmX7lZcsEtc4WX7ZPXBRf+Uj/OHJXK1tJ28CS0xsCuAWvHK8j7dQi42lk+OdQM0En1gOp95ef+W8+GZGC6rcLE+ffXJ2lJ8DcnWMarXt74+pG4svw+uFgjVieCAEWg+c0+KNV3TdlToqAok+FRQL1ZqZbFYlk2njHfKRNfsEq5pMcuY16utW3QJ39e3XkY4t6zsY5U2aaWI1U/Wn5W/xOWvuSFrde4zK7du4tUVWjfVHP6i6/jA/ISS21bNy+XJUxsKIFaF2Qf8rAxnxVlorLLZwtYLmx20XSpWFUWYQ8THADKmvUeOqHiEHuhAv8GYjn3fY2ixtiUyY02DkKjDNAZ8GLFmBpS26WibNxxeHlNcazZOFFaC1IkRlQT0ItmVbkzRvnJ+xlrCFIqyvO5jIISZaR45no60myYn+3xOUcw9L2Vc4+W4rNz4Je9piWaV5csUcbAIGEEqb2/SeeoF0niaRWWxtsE4u8ynmMfQ5D0jf9fkPZ4aB5n2nhhiruB0mTW/HKsY3PrMwgqdXsjU1Nay316CzcUqrIsBeumNdIbh4pMqez8Bvum/Mv7F6iy6Wju1b1c3ygwGZfVG1Tw+ZSOD1cKlIk/NRQKgWrEXRKqr87XGD5d+qUw0Wt6vZSbZ8F7CM5SY5VI1olxI7VVf6Jf31S8dXw1W9/sb/vf/+H8wDjO7zZ55nPj1hx9TclXXsel37Le33Nw98Acb2bRbNu2G7e0NahMnmFjDttmAAe8bQhgZ5hk/+AQiZ8/5nKxRu+MpDejNDTFEhuFM03Zsmw5UMoYTrM00FdiVQI25XkrSuJ4enzkdX9BUIzElTznLtnM4iRDSphmBIMo8vDBOZ1R94iRr4XT6SCMR51pc02ODp3GC6IyfD9UlENUhIRF9O2dp+i3ONExT5OX5yA9//q+ZFusGVPn47j3n4zGVK5MlO9PaXIM4SLZsSf5c6DY9u9tbtvsd290GozuEieGwYzxtmccJqxONacA57HaHaVvczR2ma9lveja7Hf/b//Lv6DZ7/vLuhY+PT/zy4w/I6Zlm+gDyyN39mf1m5q9eG8ZBef7o+fGj56f3I/70JZeSI4YWq9Ag2CiYIDRyh9DT6l8TaWntQDQz58dnBv/E8MuHREkWJrwfMWrRANPRQwtsBLXZKiTXAJ5lbdYEJhYhxMpa/ZUAdXkeMjBbNuec+7amgLwEqlmgqkjmqZMkUE2Zn4KxDda1yZ2YY1Yb16TfXUNjG5qadGVTCT8pZTQ1s0XoysKxuOtTaxcpWSK4EsDhMw+fzl0Llst41FiB6YXbXxdgVTHqurb2CiQv1twlbjb4wHQ+MRwOvHx4x/hy+BTwX7e0WFX5FJRWyKLrp1+AV4FSxSHQSoIgt8YwqHL8JL7ky8eNMWxE+Bvn2EnKv31oWzZiLs5Lzlcligeyq04U8WRewuymXD2zkktk1hhSD5kkqmAbQZPVFq3zIuS4MsGTmB8W8Z72ulg3LIASW5ge2+efxVpGpSWNdcMs6kxcv9ZdWasL0JT1UZ9tgc3pmvn8/GFNsqHEwKW65MmSly3HhYs1A+AougrZVSrylyR/15BcSRaqGMAHmAK8nME+pQz8xoK14FzAuoEneWQ2ntj8ipozJu4x7Lhlh9EHXuYNp3ki6oQxwq69QdUyWI9pDGabM9zFk6KnWzb7Dd/89R3eR2avHI9nzseRcRyZpzVgDKAR02R+UulQ75hjgBhxpMThygwSA1HBjwMThuPwjHu2PP1yots2bO+635zLAlXr0JWrvSoLkixnQE6o1AxGc1xpkZHZFS11XHXlpcnA01iMK3tZUtJLHGV6JV1DwTYpRMC5ZKAKMaIh4ucUV43JFSsrk4C5fjSKObA8T1qNOWNe8lxbrdlCvF8mzeJAirWvZAUZE7VT5oSVElZQNLhFDq0z560VbNZFYpHnKLqqcil5zxCTq0UZQ9M0qZ9M6qOQadOsS3jBOpc8LzF7R3KVzsJDUmShSBorXxNKU7ECwVRuV9fYjH8zx23ldCb3m1ZQW6y2isGWda3XoVUlDKQoFlL/fe3x1WDVuob7h9cMp5HONLxMntPzAXEG13c4cdgbR7/ZoO6ebbOhbzY0bZs1RankuMYIhE1aGTFCoU+IAe89xlrmacY3Pn8eCT5g7erxpWgAKftfWeKXAsl0LVmSBT8zTVOlYknWq7zYRBMYsA7Xtoj3TONICJHj6SWBw5CC/c/PH2m7LXZnIfiU46tzLm9m0uzL19S8iMQ2iDOoCsFHjocDcjpnFwaM5xGfY/RYTdBEuhwTb2zMG4uAkcTL6XJCjmssLrMX2KatRL+GHERuBddtsH2P6zaYrqXZ3LLb3fDq/oGu3/J4CgznM1YDLs60jBgzQefZbSJ3O+GM4hvFqScME9flpMuk12jQaJGomJg3LxHE9Bh2EG+R2BZZhp8CcRqZTkeEiDNZECEQhTAtsqQ4Lr8MZfi8urZCM594Rn/ncWFIXKnXC1CtEVPZyqJEs7jRyt8SFVWJVTXL75mSpFBVFTaAEoco5WZZ4BQgravGXQYmLO0u8VSXFoH1CVJ//SQW9cqCegFUy3F90dX70u+XbFiRMHvCPOPHgeDnev3PjfD6qeTqZ307/eRbUr9boDwsOd6tpIjE35pW14cj6VA3ItzmbOV7a3CrZy73qq7z1Wv2k6NXG2xRCuo55XvFnJP/XgCGlFm1di0sM6I+v0iRkCvrpRYF5QJGXnVivlK2wFTbuywwUNffrSEa1Eponx7r7+SNtJ63WPCKxeZ6pLXwpRZ9aIX0ZfX/AlhXPa8pnjxEEt9+pphrM2DtOqVpYPIDJs7AM5Bc/UY9kSOGjqBCUJ/2NGNxxqGkfcW4lHWdQhiKoDTJQLJr8QFmn2Jj5zHld1x2T+5Lk8ZcjCURpZoMhBZ5ACUsJmfZh5nZj6ka4nHEOCHF3H7++Nya0Yu/LOOQZloBbZdjV/SFJQSpzCtdXSfNi0XWmVrBLuqK0igr3tegOSknJaEpy7PahsLaAJfza7FOiEmW+WolhIwhVs8rV32i5P38stOK0qhonuc5zUhYravlC3L9XUleFaNFv7taKJrVNikGuaWvMIYomnCBkSWvwaRS5UaTp9loCiXRuHLZ5+4oCZOLxbjgKcnhG1JFShHeixH6MiSi/p31iluLf734rIZOrCy4X3N8NVidh4Gf//xn3r3/wPuPHxBVGpSb+z0PD99yt7e8vt1gN7e4bUtrOhrpmMYXDk9PuZqUME1jstjMExoixhscFieSrBDTzBzhdDwAqVSc2FStwzqLxsQx1vV7/DzTdV2yQkQICAGDzgncxjATQ2R3c8t2f8svP//E8XDg13c/4/2cKgZZxx//9HdY50BSsYKffvgzp9ORX9+/T9a6pqUJA8P4QvQzZvIMw4Hh/CvnKcDoEXGIOJzZ0ZgdL+eB4xi4u7uh3zZsX33L7ZszH99/ZDweGQ4nQNHZJ0oHMZjGsLm9wSCo98QQ8LqUThNJWplzBh8z2X5raEODiVtOfc/Q9UyuIRiLdSljtnn1Cre/xW422Kbh5vY1u90esQ1BlfPxRBgH/nBned03fLvvGIPjaVL6Vtn3Bn+KjMfIeFamgUsOTiAHsxBmiz9bppfA+KI4AyKGKdwzh1sOB8Nwnnl594HpPBDPZwhh6YNSO5qGOAnhQ4Q+olMkviiay+Fe3Fq5dKdeo5frQ377z/W0uj9+KkgUrRmSFXuwxPBVKiibvhCzUBOxiaqqaWmajr5tM0Gzo2kcXdvQZhYA55KbTKxkM2IB6wVU6hXlUKztWDomtV8WGbJsGlcm5mvL6eettsv10+ayWALKZ5876paV1PokvqImfuOQqvSopLzuAiqu3ZdSvl9+59KWolevdRrk+8X8aiRZZJwkF34iJfp9x0GVUZUPOTmrF2GjixOxtCTiUfEp8SC7e9FskYySkgaRhdZSYYkMTRQ3SdRLjT0WiXnckmzAxBz/mqGFtqRRyvR3Uj4vHVeytgVUcuIPaIlX0xw3p8kFb4qnKpdtTEp+zv6vY1RiVktsa9rkjcSLBXrtFlzHSldvZrbkyUUyh1TuzxjTpi0lT8HAkrhYnoEV6EnzOGRwX7l+MxqRAGcvnEVwY4rTa25eY/uGrXuDFc8QJ4IaYqY72jc39Nai/9ag6kl1zs7cPUBj9+z4d1gs8JYUINLRNQMP+5bxBOdJGAgY8YhMFxO5VAVDZkRiIn8Xh3UNMQjeeyRKkq2FESEqMxPMwnA+YBTeNS0PzQN3bD+ZvwmC2jQ3c58Xi5lQmPKWhJpiFy80VyWGvYQ9RqWusYy0WH0rj282LlmDdbZeO2hAQyQVC5C0ZirD8gJONRYjkK3JhkZMCsHIFtTiEargSEq56jSuaT6s6ZZgTVm1EvqIgCsFCvKDhhK7H2Gp55ZlY0xypCpFMclnYwxq8h5ucq/UTltyLLKplUJVFxOoIVrFqBJ0RnMb0LyGMRiT+WZLtb8YMZLyVYIYokl9ErWMC0jevxubjIfpqTXFqJqFZrcYREqMqrFL30DRq4qxJCX9FSV6GfkV5q20hUmBlq8NWOX3xKwGz/H5iefHD7x9+wuNNdxtN+xCS99A3wibztDuNmzubrA0WG35MB45n880XaLg8T4QY8AEzSbrtHCsJBd4jJEYIvM84/1MKHGdmQs1ZuFdyNStdQiRqIFk3M8beYx5gCJdv8HkBBUfAqfTkXEc2Wz39L3h5vaevu9BAtN45OXjFmHGfUwlPhPnZdokRDzECdERIyNznJmmEZEGQ4M6h9gOHwKzT9W11Dhs09G0HapC9KlalqCZajq7/62l7ToEsmCFEJJwMJqSiJwr5eVSokbJHCfTHtXqR9mqajDYvsduN6kimGto+y1tv0lrxQemccTPE70Dp2BVaUMKiWic4vJkDj5xxX3WWVqERZQkUCeYx+QyjxF8cEzBMY2RaYyEeSb4mcVSk7IOpSagGIiG6FPSgbafgtSvOeRzv//+yyxHsRZdgeO8Zi818Aw51gCuaJM2WxfW1apstqqWuOdCVVW1T7m4dAXGSzJTueenz6xkEb2y0KXN6dPn++RBtP53efWElz49rvvnCyckoLuKxayffgo4r7/9pb8tLf3yZwX0ipakn886EH/z8NlSflLFZWE9VHC0uq8kGihZPZXWp6Rm+tZIOS1/KxRSiwJ0+SC6jHce0zJMxVpabfnFYs7S82s9rID5tZGl9tTFBpPfll8u1bLPd9QXNqOLsdOrD1ZWngKr6pfWmerrHVMuFSWpnXo5n3TppIvba8nIJ7loQ3DE2GK0wWnE6FBpviIBY5Jc3Dc7QvQwvACJwspJj+OOZH55ynexGFGcdUwkd3YCX/LJnCmtquFOpsnVhwwSTeaGzZngOWY5WVxjStj1M96PDNOZad7ifaT5IiiQpe+yte/TMbqUX0VE1M4rfXjV/rUCUTTkmuAjixK1/va1BXCtr2oddqngZwlTyNbX/GUpiki+ZgGKiwVTWC2N2ooLSzEr935O4I3F6yeREhFbVnVqo1y09bJfVkL8s8IrhypUJoakwGtUYi4qspaUFFF+ARxZFP3cz4mIGNY0OsV4YUwOUcvPte6P4j0rIY41lELAED+RS8WgISs5WOXG1Twov/8Ow+rXg1U/z7x7+wsfP3xg9iMaDedBsez57rbl4dby5kbp71q2r+6zBU75+O4jP/zTP7G73dD2bQ34vt9saa1j1kCIKatejOF0OhNjZBoGnLWM04wxlnN7QlXp+g2FdLdpO/Y3D8zTwDycmUspPaYUz9FYGtvy5s03bLd73v76K49Pz5wG5XyOPLy55/7+nj/9m/+B7abn+fAXxsGjU8/5ZWRPT8Rg+gf6bc+r73e0BjZmZpoC55Pw62Pgp3cTKc5oxu322NYxTTMvxxOHJwd+RGPEZYtZaNocppC9O6pI47Btw+tvvwFVjo9P+DkF6BcwYozQOMOm37Lb79hut2y2PbN65uhTdqVIus+mJ/i0+La3N7j7Ow6HM/Psubnfs9/veXw+Mk0TP//yL4ynZ2Q+of6EzB9pOHDT5QUeE+CcFUIryJ1BB4VTrBM1pUJa5uhgcnx8CkSrND1sTODp8Mxp9jy9bJlnwW4cXdtjtpboI9NhQjRiXICQyK7FS7qpVRg1JcXeG2Tz6fRei7zrvWzt4q7tvfp4DeqS5eVK0BYlqKzKLBBjWcy6vnR2U0kRxVkMyhIK0zYtXdPQNK5WrmqahrZaVh2NS0mExqzi0yjgNK6snVmorKCklgdUlqzPzyK/AgYWi+qaOzVZEeKlUKpS8hK8yvIhFehcdvk1mq/WkhKrtTzf8vppky+3uPXYXQCT9X2u3pfvWKA3hilGWkqM6b9+5Ihh/pv3WIRW4PtpuizRKiUoKSzPJKvNTVcFLoScYKHLPy2gpFR+yafatOkV3JVK0uoqrSgnckmyvNpCw1NpCPI9YyLUT9cRiKZa55PSqMmlKKCSeDQjIQPWFFQQM2hdlkpeJ+tdVIqVXMvbZZNXavay1EpRpZjLlYs2Jlm0bPmSm50U+grJy1qst5dM9Zg9AVU1UGqqXL6oa8G1QnSPeIm07NjRYeVbPC3H+YTqB6w9YqShkde00tN0f0uiteqADSLbPEsy7x49cxCO08D7w1t+ffszwzgxjhOhxg4WwBDz3EltjHZOFsmmwYhNVRtz2XJUamiNauJe9fPEbB2jHzg8v/DzD+94/apj991iYU0GuMXdjsk13TXFy6aMe9IcqNAtjdVKEi5LvchDUviaVmC0KBxS6tAjaEjzC5PLtJr0mRJTHDdpH0sMKC7Ldc3lxwtPJylEosSs5raljPyIqrmYd8AqcTm3v7hySi6bAzEmJbshKanapJjOGJUQcsiGTVkykl3za09jyfSngGS5UodFVnOYevPGJbtsWveJulNVmeYZEbB5jAqdphLyONrUvwIxRkLIYySpIqdzKZRQc7lVRPA+swTYdF6JqfG55HyUXHVOcylXk0YxWXE1jzU1mapyQdfdLo+PTWwoqRSyLAAbKXVuvvr4arCa+Ofm5LLTZBHxIbmqRSOGSGMjrRNa1zAzEeaZcRg4HU9gFR89rkkxetr1YFIVjqgBa1JFCinl22LIlFUxWSnnGWsd8zznOL8m8du5huB9nY4JxKbs96Ztsc6x223ZbrZ0bYdrWiDFkDrX0DQtTZPcsCKKMYG+U0wAvxdCNERn6Dphs4HWRrY20DQRK8LzOZerq0JD8gROPGjzPDNPSsgCRrL2ZEhWxOTBEiyJosjaVDPQOIeJMRHmZ0Bict1q1zi6tqNpG6yzhByALUVbzFZao4rV1EeuaVEZcuJGmlLH85lhGBiGE9M40MTsdtSASsy0I4qPif81IKgVpBMIilrJ87OAu2SZCFGYJhjOqRhADMrsJ+bZ4X1LiKlsbgqwV0QCYm2KJTIKmfaJfGlCXhlWktz/2nrCGckU4KYsrtDPwyA++4cv4bzf+s71x+X7JbbIZou4qVbV/Jo/K++rZfXqylpAI5/gv4v71RM+cdOv4wHXDdaL9wVAru78m8/8m8fnviNpvRjXJqaPr/hKGY/Pva6/I1fvLy9SNuBUAteS6kIV5/nXHAoZnCqjwl6VcH23knCwiPCL+y9zNLs4V2RSGiORWEHshcVzNYmL9b4+f44vre+12FIv+6W0ayGMWmXbl/OKJUQXdpU116Oselu49CKsaSiWXslzcZVUtnxnnTJ3oSmSChGsQJNe9EQG++VeX1ByPvvp0hMCWCe4RhAbEsl6TpAqsa5jmInq6axP3sPYY0h13IUGuAEcmmNVJc+slG7aItojODDJ5WpdcRyv6Nq0PGD+MRnEmhQSJMVdfNH6HKBRrKu5jPg0TZxPZ+b9530HaQwKeFpA3yeddSUE9erDCmTrpDHLVWV11soanhT/co6Ui1Az0Ety3ZXFN12nbDlS35eJUN3M6yb/hsDX3OfrhNk6p0yxrurF85d7mJyPUOm/1ppSvcjnZ17tCqjPDCXs4dpokAnbaljuyphQ54pUp5hmAWBNst6XqVQtrqYkqa9HcbmXfHZTkWooKGOyZEDkWOasHKxl8HqbuZTNvwOp8jvAqjGG7XbLcB6QGAkxMkwzj89HfvjxVyKG19/c0cYHxBiOh2d++cs7Ht+/5+XlhWE+YxvLw+sbNtsejYnn9DiemeYJZx0NKQM6xJSd7+eZYTgn8BQn+nFCUfrNlttXb7CxwXZbwjByOA24tsO1Dd//9R94/e0bui6B0/k8M08zb779hmme+fD+CYNh021obMPjh/e8ODg8/UwMzzg+suvPvPmj4ifP8+EJ27XsNpG+h7s9+NEzvRii7hmGW85j5DQG2n5P022wTYdxDfM0cgpnTocnTodnYvBZ9pdqQFkA25RVeTocq/vDNQ1muyfGgA9JuzJW2O72vPn2O27v7um6ljA61BiCRrxPMUiucTSSwOq2a2n6jo/W4uPM27fveHx84jiOiW7q5ZnoJ5ooEBwatkQ8IzsCE7OeeZqFAUPoDe6VJXZCdBE9KXqmpNJmsKocD2mxfTcI/UbxfsB7BTqMNJhNmzT4c+JZs64I4OzSMUkbjZ60QOesqX1OkAqfsW6yvLlM8CxK+YUAVqjZP7o+mQS4jaFWRvrk9ivwW4V1EQ5kQJTjtFytTNUlRSkrTF3TJYqbNv80DU0uY3zBzFKE0bWrnvUW/6mgKUKjCo4V4FCuBV+6fogr2FZAq65F0dIbpU2mjo9+rhm1zQqIMbi+pb9/4P5v/0dAePrxn9PGcR0TvTz+Rezppags43s1jtThQEkhNtfRC06E3giDwv9L25s9SZIkZ34/NTN3jyOvqupjGj3g4BRgIcQz+cw/no8UiixWdsnFQrAApme6u67MjMMPO/igZuYWUVkz1dild2dlRoSHuZ1qn36mx/IZRvcPXasv/Xqpp37AmKARCMrkK/2cqDCxBs0vcDkrjZJiA/pKJieLpAwGZM1vTnnPNEd3gI00R4HQBtNIL/2VQZ8yXtl+tdiHkpXyVGpUolIUcyadD1EKBZp5OQFYQwvWbJ713zW1aSyUaIJsdkvtHYFsFlf7xcjKKZdptz6zFJSK/yuFcq1GIGIqmN/venb3HcOtw+w8o0zEdOSn83vOXliWDVY6ft2/wrHwNP4DVjYMw4KRgURHYGaS/wfLhiG9BnZAYus29PZrHgbLr7/Z8DxGjlPk7bvf8/j4PoNNjWkeQ8wsckJsxCBYNqQghGUhhYCUuLJp7deYYJ4nBVLumbB4Yojc3H4N3K9zU0rM1FVwqte3xrQV0d+mAVp6oKNEFVGVqpjthaWGo1ImtNqmpxxrM8sGTRGa976ok7EAU2OUodPIA3ls8oOVvQxVaarAqSTPKf8JSqjkUF+XZgSpArYUsxnGlTRPURnfEpuUGHVPC16z+BW5lJ9f43tntjfFhE2oV3yVhVkdlPpVLqWWXmuiI6diInq1M22eCWQQG/Ehqiq0hLx0dG2qf4R+Z1nKyZUqQ710OJeTKhlRs75YzhzyeiNRMjPavBe32RO1t62OXWZ5iywiy+5UfG3yuKcsKcqq03s1tOWXXl8MVqkTyuKMuiOEoMHCx8kz+0iUHEMu5yuephMxheztvDJHzrmqpccMfG0WPDYHPi8Zj8iboFLwCmBDX47V1LOfzGyShWXXdWw3G7a7Hf0wcAgHog/0XccwbOidw7nsbR88p9MBa5Meu0d1zDJpwcHwiiAAACAASURBVJXNwy/gBeKCQdRjPacRNMbSuaFS9aR1MqWYWOYFkUXr7VXbNpmBRJrjg7wggw81/Zwek2gdJJbNQ9us4bdcpug1EoFuJCkvJINkIW4kO5Zm3n2cJuZl4TCOLH7Bx3zcmL33vTcEsUx0hBSZo2FcInMQfJDVmr4AH9NouVkj9EvCzxC82rDq/MwCplQooXtUaMqKDRiS2jXquVuca6+ATLr6ff1+0ZobgvHye6k+6hKoChT7n4INW2CqbVrXR2pf5xerEC3CLXv8t2tCTLVfXaMA6EZRUk5eVPoTLPWl4OplTfY6VmoR6i894XOs1RddLygTxjps19Ftd9hu0Cp+wSNKN7S3f24evFCFF0FaQwD8u66Xnlunh+S+W4Xa+iW5aklVCNrBvpoD1xNWyveo/9Tb6gK4/N56xrL+VZ4p+d9LVqnM5pXJvSSNsklJVSqv1nH9/meuhoJJlcJt+4i2gU05BaqW+6+B9zUkaV7JJR9sxGDF0pkNvUmY1KEs6QRESshXi8vhfkAIIGN+igMCgVMuczUsMQJGlFHtcGA6rHPM5yNpOauZVdToNTH47OgiDEOPEQfSkRaYjcvtykH0r5oUC7saPD54lrAQ06fnBRdjV9a8NNCvUc7XGZryMJR53Ng5SivrzDqrSuizz61MkdVPIaUMltex/0SZLvWqTN+6N9a5n9bpdHkiUU6l2sZfAda0gtwyMzTd9Dqfr+dwXQ+1hxpg15yOXe8fbVmVTKixhDM73PTvxRNlXU1VkYjpQp4nXjaxKt8tY1OY2KvdTfHGdYzvOuE0+kDtp7xOi/lRGyt3ZY4/6e4vvr4crKZ14x6GDX2MbJaFTnpOi2WSPXH7DWPqSE8fOZw+cJrf0e8Mb371mt1uz7AZuNlt6TuHCVHTi0aDj4bgZySJhr5KcJxHhHxU73q6TgOoB5/wiyYhEIRu2NBvd/S7Gzpn6ZwljBOH9x/orcVtNhACfpoYup79fs9m6Dk7y3h6ws9HHp9+wlnDt6/vsHHD8ccZ8SMheaY58rsPE5u7yK/u9lgf8O7M6QDv38LxPIDsSfFMmAPndGaZAqfDE+P4wPx4gOXM4XDGL1EH3gm+aJhR07cG7zHJ0oUtIpbe9Spw8PVoxzqD7Ryu1zBbJmfuMMbi8jFqNEbty4x6rYYUidNEms50RvDO8uHpmRAih5w6trMCYjgvgWWOfHg2eDpGe0uIHcsSOTzOvP8QOLxNLL/zsCTSkhdYL1ijulNcJpL3LBYkGqajY9panNwwuC2ePSEZfDqQ8MhGPV7V013T66aoXscIiBWSh/gYwYE4IR4/FXrxYqLqr6qY0x45sqISKTI6fbpOSRlEZ2BNIgR1tKtJWqAKWsMqjFqhXgCpM47OODrX03cDXWFSbY6vmm1WO6e2qs5lR6uaWnhVBGoNm/p+zr6zNHf9W+oBXRFeMXuoXx8/rd2ZGnDDVWn8QeFzXa/2pVhLt93S73YMuz025y9PrLFhL/bT5kdYnZPaz1/6u5WRtd0UZxllWkNK9fX/vEu9qY3YC5uutTYRJHvsx+JFX+yS80aUsiZo1g1WN8RIwub22IqBhZSLLE6hqXHtpR7jp/y04tncHicakypuMfWJuebZlk+XRarh+soGLdn+zkobkVXNI6R8DitoJ60bXOmbnKUrJTVTLWxtCSpQxr2aLBR2p3StKV/OAK3YXMf8/NbxpwJcrU2YYTkJDzd/wqv+HuEOweE2H/GceJTfggR2vKFLHd3mHsj2wrJg00xiYomjVkRGCoAVDsDvcByxPNO5P+fe/i98+/2O+N0rfj6NPI0L//rbf+XRL3SdoXOO77//DUO/4+OPB8bTzHye8bMhhUnBXUkaEIoT0EKIgvcTznXqDX61dte1oH8V+2hTjDelBVkr0Ej1iEBH05aSrsLrKeDU0Isa8CooEI8aeL6E5DPW1oOvWEiTa0a1/sSqfBgxuGwKaHJGJdtZ3Tu8ZotbOY1UmeRi26+YMJ8ENCCwbg2GTAzluiwq9E2O7lKmb0irpNI5WfafVdkyzmI7WxnhZfYEH6q/U1metY9TXv+ZFLR2XV1F4VX/lU12stZ43n5ZlG/KxBbZMVpDXql5gSQh+YTrO2VMJZBiZAnhAqQrC27oeltjvV4AcFPa20iIJCrSjAET1bY6kg2BBROV/pMc7aCEZvvS6xfZrM7e42PEZeFgrE7VeQksIeGTaBpOOTP7kRBnbG/YsqUf9MizBDgvAEHEYMRWcGIqrbxewmpcnHL61WWZNWC6tVjnGDZbnBU6qxMsocyvXzzLvLAsC13fsdvt2Wy39MORcTrBpNm0+s4BDyQc4ywwG1KyjLNwmCIsFtiR4swyzSyzMAeD97ZS6USl1YOordA0jjCNpGXSyAAZ7BeD7WSEGC0lZ7yxxRNcAUrdigWKCr3acq7p7mjGvASNiFmop5SIfiHOs5p8WosdOhUcxhJSgLAQo2eeJ6Z54jxH5RJsR4iBZe6Y5sgyG8JsYEYN073arUreHKRAjCSkaInRME+W6eyg67EyYK2DJDkYTgCrziN0GqpEjexXjqesnhQTsuTwPf4KALW/0/Ubq6JawGn5rDKlL+C8FtyWckuu6Qp6841V+y2acOJy0VftPx+nGFMZVMnC9jpT1WUMOqnNaYFwacgfPbVutdq1uBcB6TUevWRSfuH1BV+pqfusZvSiZeS+oOiLsXip/D9QpWsQ+9L9/6PX6qmsDh81Y8y1kVxbw9q4OvuKWlDb8Gk95YVXeb4WgJqfG5uFUh3z0sWquyixsEZl06/znUYe1bvX8/0Sj0DfzfP0cwvuWhVpjjuqbeMF4/+l8zH3X1r/vu48BS56TwiJZY6EJRC9x1oPIjhxGNmylTuSeGzsETqc9CQCIqemPItlg8GhEXxHpInXSrIIW6z0Gr7JdECHO0+Q9FjcGMOwGRj6jqEf6N0AclBQbzV4O1EJiTYJUZEHqnRq5J0XTWryvKSO7FW/Vpa7AapNH8pFOSv4L6eLJdPTKoQ/fXZ7tKxTQ6h2y1kmXTjmNfUtjkYlpGORv+1iXptwNeDNNJD65dx3NN+9eE8nyLoOL+XuyhpmCZ3WcrVacvWsS0a67B256bWCsg7sWv2U62EKFlA8EIs5SFIgXgqq8V8LE5v7qVSnDfF6seflyq8KS9u/LTZhnYBSiBBZ9508rikrVRfS9v8PsLrEwNvDR8bzmTe3d5o9RQwhwePTM0/PRw6nCZEzIp7n8QMTR7Z3D9x3t8ynGT950hLUsDeqt+HQbTF2YGJUu5bO5bzqICkRvSf1HUOvHvR+nitIG7Y79rcd292ezXaHwWNToN9u6IcN47QwTh/5+OEj5+OJh1eveHj9FW9/+gkx8A//8f/i+fDEmzdvuNnfErBEGXh7vmEZLWnZMC2ed8dnvrm54693f02UIx8//I5xsUxpYJxnTocTy+RJPoeYEOHp6RFxDhM8RM9pnJm9Z3Ad1hh624OA79ShyuUj4GF3kxdgAK/mBpFINDmji7HEqBm9pnFiGT1+DgQf1eMPwYdE8HoUH2Niej6SkmFze8d2t+HbX/0a1w18OC+cp5Ef/vW/8fx05u37HzhPJ57GE0ESsRuIwbBMcD6cmE4zYQzY0GnGr+hXT2QbEJuUTLBCMhui6Xn3tuN87rj77jVuu2dwliAB03mSmZBhxM+B+RyIY8I/ZoN1ElEgWdReLmatPiTSfDU5s3AmtmB0lUg5L4ESpJIJ06Q4uZEpdQG1i1WKV24rVNdb67qtYabyaraZ/SnH/TUsVTYBsFYTURhrq+btnP5YV2JMrscvqckERIXzTQe8cNUj2RfuTIDENjMVDSsga5+WjTA1bZe2tCtB2oKtZhiKkItlZ617omTHkR7TOUxvCEvKSssqG1sRV75eWFBz9Tlc10qva17TiI5TJ8KCsoEvOhb8O68COowRQtK0zSmhjqUp5KQlCsJKGtaq9KW1k6Q0uu5m6giVMkloCgubG20KaLmIyQshScbIDYDIz9TNLlRA2MagLEhOIwvkGV5iXtYnlL9M3nCLZ3DI7L3o8XRuW8p2XkX907iZ2R4oz/mYN7uqu5QGVztZsyqSrGCqmrzK5fwrXu1JFESvszdzVpKYThPLeeHd8C/4aLm5F/reYtP3WPa8jn+JYDEcAYPlW2BE0n9En/AGy45beUA4I7wF+RlhAvYkHoA3JG7zADwBZ8BzeP7A+w8fiWFh2PT86vtvubm5wc07wmw4njUMpPTgrNOM1yGQ0shqSqJ7QEwBv0x412ezgkszAGPUUVdP96LaO5YMYamsy2KzWiRitldNKZsnrYCnMO61DtkULubsVPquKjI2kzKSlfWU3eelQU0KXpVZXDGqVD1PnTI1ikPJuqQVTznYqTS1QcsO6WJdlZFfTRYEKnurc8+HWNdevTclNKuc3lfIBlLK/ZjwjRF9Kushr3etewt7L1WGWOJllyP7iz7VCCKpMsJJTzlTjleNIZFDSFJsTrNjrxiMs9l0Mp+WlNAFaa1I2QJiI4HruUgZ8FUrWddxszlI0ogMiNEoPqChKONKRuqpk7vegD97/SJmNUY9pvUh4MTQO3Xs0QH2hDiSCMS0MPmZOQa6PFGXRZlGlyLJdVW4hBDWY8dmA7PGYkQ0zqr3xJJCTHTQlmXGuU6BbfauTiESosf7CNbnYMHqqNRvN3RDj2DZ39xye/dAP2xw47lqbMviIUW1z/Qg0eFFsMOebnPDZvtACo55fCJJRzdswT6x+CMhxiyk9Vh1nifG8YR4ryni/GqgLSQwGcw4hwC97S4MmctCLscXRgrzpp6p8zwzTzPzNLHMGnkhhJDZVFYWQyB6j58nJARMSuw2PcNmS3Q9zglIxMeJ8/LIuIzMPuV1pfamyVtIGtfWOY9zHR5dlCVPswoyPZ7AGoxzOelAz+I7QnCYmL1ZRSMAYAK2y8dPfcjOVCaH3SmbigogMZKzmdHsQFdztM7VF95s3m8jAjQOy80XroTmSw9p/tRpKaym/jQMVFnkZY0Xpk0oBvrFPvUC8F6grxYoNzD1j+Kq8o0rwFqOUS9Ka8VlcxUm7LOM2B95fPtn87oFOMZa3HZDt9vT396xnEaCP+WwKH/8Ee0tXyb2mvtFEwQYqBEBLOXw+n/OVb2bMwhIpMZMVSoWqJtXMtAATZp5VSdGFYbX49ucyJTXNfaj9lY1dciDssZ2bebC1Qai9m2N4iCrBaq+NvVOIIf+yfZypS11o8/TieaRF1v3el2wVyVIfHXVKCc5V2NV2OIW7H9ypYsercMRNVn3eVyw1iN9wkehM+8wcsIlEBzIKYeu+k5BlUxaVnomMWC40frKWYGqHCHNCJ4kGqYv0aN50AAMIUYW7+mGjt4aNv2GzvaM08w8RrzXSASS7ZDEmGwWIXXIyiou5jwxhOxkdQlW25lV2LP1NKec/hQQSCW6y/xdy2nmZgNWCrisdpY540SN1Vln0jpG7XxYP8lzS5I6FRbg2MjXT66i4Mg6vpcCsO2AwnCuQH+dG3LBSl/YXWYwW2V8YStTWd8lsUOWUWl9qNSqyUV79fmNbWlt6/r82HZxAd5lTeWbRQwx5XgMbf+sAqaeshTm04hodKlUYrhLxR80JMxFRxY2uHnAaqrQiLfLxbn2sPwyef3FYLVUM4TA8/HEbthwe3+bPU89xpzx6ScmHxgXz2GcOIweYULCiQ/vf+Lp4xMPuz3bfsB2apt5nme1YzFq3E7SNHXbfkCsZTyfSER200DnHJuuU2bxeMCIYTcviLUk55jPC9P5hOkWTO+4u31gv9/y+uuvcc5yOExM48J33/+G7f6BH3/+id27nzEErDU8Pz3j/cL745ngPdtugxs2fPPmW7751a/46ru/4HR45Pk50G22vL57xfPpnzidf4dqEFbZAx84Hp405t3sCT4ynvT3nHJbg4Yn2t/c0DnHdrMFgXGaQMB2HQjqjJYndWc7OjcQfOTp4wce7+758O4dcZlJy8w8Tpp0ISUSmjxAjLCcR7wPdH2PMcL9tuPmbscdlqeD5T/FZ47zz/x8/G/MkyeFNyAOCb0qR4ull4Hbu3tc7GG2nE8jR87Z+WxNF2gHhxsG3H6P3WxIbsMiHcviYBLYBkx2WBAz0Q8BYyJ2v6jd16HTBRsy+0LQ0C0d63HX1ZUyZtal8ClozZFfdDECUnCAuSyvytWS4UbyJp0uP9e1mJrluya1uIAXQmbDTc2gUtKrWqtJG2wOV2ayjWq5f7X/MutDmzbp358D7SrwTN7Iq0jJu0ENZWTWcqqC0/RxUeIUp34C29siP+3DdFmX6gXeiD39w9Jtd9z+6luW6cTrd3/P4fe/Jcz/TW2Vr0w+rvec9ne7wV3f+7nLoJEAOmAQKcYpLEgO/P8/dhkEk3KGKpOwGUgVhjmVQOWpmVz6AeSEApf8Zd7sRdD0aG26gTWtYgEKytPmTb5Gd8hzSUBS1Nia9Tg5ZVuyVAepgFElNdVp0+adxmRnGDXfkvr8whQro5rwREJKekpSAp2nREtSKKz1ecOUZjBLeC0tO9auyhO4hicoH+Tgmak4mK72wJLSuv5zP2m/5bpEJRvevfN8+Ai3Zxg2ke3N/41zCxLvgQ7X93T2nm/63+AkIHwERpD3wD0p/RVwQPgxA9YjyBk4Ag/Aa0h/Q+Kv0FBXPVMUTjHxJ98/cHu3pws3sFh+/+O/cTgcWbyeKjrTIxhcP5BCgFnjeJPZvoCuZ+8D8zhz4sgyXx5Hpdw/BdyYzAqazHi6zumJR+6jwupJjBDVxlXRxgpoqfMgy1Cd/TVygCnmC0UOVS/qFihySSBIDlpfPq8gOJ8gJJ2TSVZ5Jlm2XeckWFnVjOylgF1TZUclDo2ytt6rE5vJr43NKU9TyPev87+C5xA1y1R+ZJvtqzDVRkwOd5UQjdjKemKQVnv8JNhi6uBsjkYQa7sVq+o4GutyKlu3phQuySOynJBYmPG8ARqLmIQzJRlzVh4ySSa2a2yMy5is/WzE5gErdSKfjMYqkIudben/RkJVpeNLri8Hq2LoXU9nOmW7jWWz3dJ1Qj8It/stRpSOXsLEEhaW6JmXCRcN4/nMdD4xG4uNYAIghtM4E2LU409j6Z3DZg9pEanaYcyT2nUdflGmdZlnTqcj1nXYrmcaR8ZxwkbdFI7mRPCRV6/v6PquapvWWrquZ7fdMe72+PlUDYqNGEoQ36jneDn1pcuMgMP2e1y/wXWD5oA2NgOmkNlAZZIZhbBEtWMNMUdK0Jy+RgLRKkua6srLEy+hbY5BBYlN2Gjr8QkklmVmnkbG8wmCh5y2sqbfJEFJlacUNn6asd1E9EHDgIgQo2eaD0zzgZTOQMDEM5qRK+XFs5Ak6rhYqzFgndNFEUIN6l0Xv1lDNWEsSQzLsuhmFDzRzEx2RroFN4QcVUI35SixZv1JBEWWJiG9CioJ5KDon14XQO6TDxtg9SLi/czrz6yksnAla6VmHcIKYFcmdWVMjawhY1aG1VQA0np4vvjwF+qerj745Ba5vrNKkRca9vkCWg7vszAuff6lXL1XXhtrGXY7NncP7L/6Fn86cuh6YtJ5/SXXNVz5Q5dc/RhUEHYi+Px3AfSFYf33gdaq8dRA+CsTJZV60E2vMFbFFKFkyCksFOv3mvfaf/NqzfeV8c0b/IUNYaprQVn2RlPJINoUMF0x4woUigKzzvP1eLAwK/kurauknKlQg5ST1qD37dRs61evtLbtIiKAgLT2vxXkl9aVtjRz/cI4r2XJVpOGlMuK2clzGkUD0TtL6AJGjogYwjIQoyP1heW1mW3+oGOXjiQCwgMkBzIRJBI4EiKE6On4BifPuRdu6IcN233HZugYOsf5ODGPiWkeWcJcsydFEkaKY5UhiSNKAAnVjKWwbiEGfPB68tdedezzC9Fsh8WOnnrMay6+tMbpvGLSUflQgavJszDvb5IN+SvzppXMe2oBSBf6ycXYlLlfYvxmnFzH+0Kda8upZTVSJ4PgyoaWJdJ+zuV+coXSVpDVlNPe04YFbOHY2uOt1E71vVQAnDSlNfXV7i8Zy0q/5aD9BlUwjMZY175bzRPKhL84rSgbmYkXDKipe1G7h9UiLnql/pG1gzaIR/lwjSyxygn5tJQ/eH0xWLXGcre9I4yRaR4ZhoGvvvqKh7st3317h7uxdMaQ4sI4PzMtkWkJyBSZ05nHDx84PD7R+UQcFoI5EIGnw4kQIpvNFtd1pBjou55XN7cYYwnzoqAuavaE3e6W8Xzm8HTgeDhyOJ7o+w3Ddp/B6pl+u6XfbHl8/0z0gb/+27+kHwYFeMuIGKEfel49vMYgfPzwM6TAZtiwWEffbYCFqK52bIcNzlrGcSQi7B+UqR36nmHY0g875mlkmc8lPgmnw5F4PGHpMJQMEuCrzZaC5t3+BuNidXqIOR2tnydIxeZR7VVd3+OGAYDpfOJ4eOLjx3e4lOhI+HlScB9VsxNr1RMvBZIPTM/PBL8wHo90fc9sLKfzM++ffuDx+ANGnukkYAMY0+HMRjNXxYgktStcOocbNlgPtk8QY87tnheCAEY0zmvfI50liXB8foKY1PEuLUzhiBkWPdawkWUKGuZKJAv1mSiLCvwOzMaQhgR9QjafTu52863bnVwvg1U0XAiQzwFVqM5Sn/6IJu3K6eps8Upl3cR13ZSj/nzcn5nV6kxlrdpcZUXpUwvMBuJd4cuVlLo8xl0FyAplVPgVAPKycFAG9ZN3s3CJlwK5Mf14uevSxa8LodbcJ0A3DNx89RUYRxI1i3n83b+yHA6E6fAJEE0v/LyIsa+u9pnl2L++nwVzeW8CLKkyrK296y+6yq6a9OjfJFtZZkDNMJO0mRChhvpZ52plOoByJFD3yDzZy5FlMqUwhQaSgVqEDBBCBYdqcqO9WLPO6N61BhEQoz4KQGEry0Zm80ZmM/O0hkiVjBd1rphczxQTSck2Ba/tvE4KEI1yoG1hWl5pVx5sqexvAao5qkidk/n9qO0nmjWrVVtQWUX5zDJJdl4NcHwynI0lptd0g6ff/BaxE2F09C4Rt0EVcvbAESP/BNyRzD2SXhHT36N2q5GJM8/mxOifOE2er9zAm24D6c+B73h4/Q7ujtxvB3pj+ZeffuLDhyPjdNakMiafskkgkeg6UafEsEGC10xYSRnWEic54UnziG9Ov9ZOjZWUVgdHh8uyKOYTgAq6coxTU4BsatUiLUuSrQwkZBvloKxfyXxV13DK/5RyhPXYuZiJirKXsTjlZKVInKlrgqSpa3XtSn3WWnxzahQTVFO7nOu+yMhKuOSVXhnfBnnJCu5KlICSJauy/nkt1lMpyl4g9buxplEu87SJQJrKaVweI6GGnFzDWWa2OsVsruH01M6V2Msqb0wtX5NFFFPOmDQJSiHo9HNtZFI6FmvLnpXXt9VjSSPapyHFvDc2+0IWAHpOsYYfLSeEejoj2p6sVHx5lNVfBFYN++2e8TwRotdsS05TefVOMLbTIMgO9htHWiY9nj6rl/k8T0zjyDJs8dYSrSUialPjA/OyEFNiHPVIYx4GOunptwPb7cDN7Q3bzZZhu8U6SyJyPk88Px84nc+czjPeq9f/EiLz4pVBDInz+cw0jmrfOWm8PD1CiKTqMRmYZi3De0+IgaHT0Bg+BrwPeO8RYxmGTZ3c1nVstltdssHXDCNTDKrNGtV81GE+UY3G0QDKarANi/cI4JwlRtGsXC3YKqAnH2WnmA2tc8iJSKox1hJCEovtB4zrwWuIKoMgERYfmBbPKcwcz2dS8hgT6Qc9YrNL0Exg1rOkxCyB4C3nc2SZYj6KyIJScpzbLCSq6pXXuR71RSRoiIx59sTgWeaAWSLn9xFxSbV/XyZ4JOExJtHtHHaA/gb8KMxWw3d9yfWH9LVrAPQl97VgRTH5yioVZnUVW6v2LwUtGiozUVRhXefaWTVwdEWXclGRT4HqJVv2SeOLcaAi1OakWd+vjEV5ZlNEKsi1jqesGkB5WdipXJc/dF33c2tVoMeOHcN2y+7ugWG/x3QDYsYXS/3cey0Y/ZLvqAhNOeB6Ws0B2nuSbtiBkkjtl0LWrHw03v9SQefn2lFAWI4ecOW8UjfMNkNUHaoroEY+tqzMaglL1nI75ajwUtVQbvcqlmLb03merlO1UQFzXSRBUcFA10gszi+FaStzlcs5VqZ2rWdlQ9c2fjKv8rNSU2Oavz87eoUhy0rjyv5pzb23Ko/tDhOLx4gFZjSt3o7IwCwjMVr88hErwsbckuRExCJs6NMtUTzReqyJRD4gvAZu2NpIlA4/LowhME4j8zITYtB5l/uomIYko047YgwSzRpjsxmilImRz5oMZVMMk+2kU3H4K88rQKyAWiEzpaWXc79W040CYvOP2r/kLq4CiNbXYR0huKQUc9irMhHaraUZ+PpnZRqvZFad+1LlrzRfbGbbC9NCarvXR6zr7lLvX59bGehqD7UCNGnXa1XULh5a11OtQ32dmdrSDpEa2rBtU6lOVRFE+xKKb8nqE1N7oJHj7TqWi87KY55aRllFVBPF66IedUiFytLWh1ys5z98fTFY7VzHV6++ggDBL/R9h+sE14GzAWs6nLzibuvY7R2P3Ue23Ufezz/xND5zPDxzeH7ipu+wRKTfkIwlZI0wnM6q0YVI3/f0zrGTxJvbr7l79cB333/PMAxshh5jDd913/P7H37iwz/8vzw9PfH+/QesNbgMZqxTb2tnHY+PHxk2HYfHA/M0YewGY5SJnHOq0RgCj/KRZVk4no4gcHt3j3WWcZ44TyPncWKz3XFz+0DwC8t0YhgGHl6/4fjkkJRwncVZy8fziWWeNAmCsVW7t04ZuKHfqmOJdRDhfDxjreHuZkdKifP5WO26BPX8NWa1X8FHCBpeJWYbFzUdSEQ0zmq3v6Pb7gjjkRgW8AGDMM6eeBp5ezzyePiAiKfv7I6y+gAAIABJREFU4ebekqaE5OwodiPIFDmI5zxF3v8+EaMjxIEYVUER6yB79KWr1ZIMzMGr1+qSHc3GiegX5oMH8fh5QYYIDz4DqBzWLC50veNut2N7l7j7JnB67Hh6O7DZby4nZ5Z5RfRdHHPAlUBpNj9WcSvQJvn55Hfe72vZRjT7qzOCtTouNmuNIjViZHWcwupGSBES5bjNNAKvglqpxzZ1Q2/rX9jjdOkGdNHMirATlM21HNNoIdTQ7q1wJx+qNUBVTUm4EPLZTAoKwL6gBi/HoBZ9PQa5TGssm2GDvdPYiY//9hXdZs9yPLcJjC7aV8akhVgvOltwNY5NWVaKlWcq1nU5Oz1MIkwp1Z8Z8CTmJL8AsAolz73kCSbZG9ZgL4eotkQnWmzP5C6k/xqkW9/NYfMaJFY3pbwxFb3jMktZorBIFeDkEJdqQps/syAYbLJqn2ryEX7B4GVOlFoWxauEs8tMbJKULUk1tqPid0HEauSRkiAlltrL2oZcfnVglHDRIzbfH1dOByi2rbpRF7BTStVJLApkhDWNqXW6JvO6DNkHYJxBFktIX+O6wGY3Yuwe4RnYInzDwsh784wPZ+bTP7Nz79nuDkQxzOKw6YH7JOyMZ94ELAnPv+CixTDz4Ebu04b//PMjPz2OfHw+cJ7nKldN0raVdnuzYNBYrCkqiRBDAYJ5XFImNV4Aq5KBbyRC8IgY1KR4TR9qKkiU5lvaXxeh1zJSSSGuXZsZ9yQp22anHLheI8nofFmdmSQTHxQzyAxyoy82yNQxLKC4BXsxrjFnCyiMrSjLxNFaSLO+ioAv+0IGuWqiVVqN2gY3X6u7R1pDRoI09r5URrMqdFLmspYRY2CVxtKYuWk9jZhaTokKox/YmmjpYnNqV01DqKisVeBurcuneXpbCLmeZb3mGhZb1RI1RxnSpO0r7ckmCCpLqORMkQ2qrArJCGtUmwJev1SW/sJoAN57ZR2DsozzPDPPlmmJdD6BF8zQs9nsmWdPmD2P8iHbaaZ6NBFiUKYtzzIBZj/neRIJYWFebtiy4+71KwWNxjKPMx/fvqfrHTe3N/h5YbfbcTqd1UYUh7WOaTzhYzlKE77+9it2uy0hBCR706eYCGEhhEU7WRKLXwjB1zStX3/9K7pOj0bubm/Z7fZ02VQhBu2L4gHvnKPvB4ZNp0B+1/MQPcsshJAncwKSCmrbqTG0D75OMmM6+u22CtQQAn72xBQJIdVxgFRTs7UWbXl2qpF8Eb4i6pkv2b/YGI7HI2OMPB2eOI6PiFmwLiDOEIMlugGwBDoWE0mdJbkA1qNhMVJeREXA2wywQO1ks92M2KxZQ7LkEFwmJy7QXTEcQZaEDAmszvTCEPSd4fWrHdt7z+3rGceAP+/o+u6Pz9eLuUvdsAtYqwvmc98pr/WsNB+VrkKuarQlRmrx6G+0zSqYSl9VrbLAjAIi1p/PtaOAmhWErOCjav1InTtrFdYYmRcbVv5Sy95Xrfpic1rbe5HpqgFHuaUXSkArkF661mey1iMrmm4YcNsbpHv6g7Dwms29hncvjef1PbBuHBWIwwVYB93AbQbzAVFnoavyXmyn5COw2rfxckwVtVGdFK5aleX+i/24blqxjVxUJ5LkDXf1/7/shXU42x2/bEwFMhbmVI97NU+ePixDjHXON9ilWQIVxFaGVUwOyaf9KrW0MrfXuflpD6f8/8rgrdO6NEiapVr+kNrW1NbLqaNjsgJWwaoYNdUREcI8a1bDWHjmjhQdfewIceC4PGkCAJmYZeJp2kNSogQrRAkswXCeHYN9oOveZBvphPATyFuQA5J+BukAlyO/yEWT1gFdW1GcWKJJJKsONkgg+diwZKuZxyfd2EyHJApyNXB8y1hngGRkHevcxzovctSHWBjWdf1X9q99brazlWTzSVRRlvQEoxwRt/U0pgnlFJM6lRV2tz2iueqvi66rC2mVb6l+0Nx3PYE/EVSNjKyPXuugRKw07H4BcGuBdb2UibsK8LXfmj6sTmspOxq6nCk0htyuaznY7FXSPrvti7XFpY76/IIrVv+d1Ya2aUNxVhb55PmlWBEl2Cgnv02bLuzHv/D6YrBaYnuexzPTNDGOluPhQGfhcN4x2MhmgP12x83+awgOGx1vzc+EJYfRSDmgv/cIS7ZBUkE9jye8D5xP0A8DD/f33Bnhu9/8KdvdHkmW58dH/vM//APb3Zbv/uRXWON4/eY1h0NmTEUdcY6HJ56enziPE/PieXh1R985bm7v1XZ1TngfWLJ5QtHfx/lMinB7d8fNzR1//Vf/gb4fsFbYbHrevL7He8/5fGRZJuZ5JASPMYa+7zHbHTd3O3Y3G7a7jn6w/P7HI09Pk6aiBcbTMzEEXN8jYjidNRWseoUb9nf3GKuenn6eOT0f8MFn7Uu1MFBbVmv0KNAUAZPjLZpeGU9xyjmYvofUkWb1zH337h3RGt6dPjD6Z8Scsb0nBUtMFj/cEqNlSY5gE3HrYVqQzRkmCIuuKltCVHVdFQSYHkyHMT3W9iqYjJCMJwVNZat2rZa0RPxjApcwNiI92BvdMImJ3dDxm1/fs3mYufnmyPthD8s92932anauSK8Vy0UWRCmuHq0I/qSEC8GkQLKg23S5uISaOcRmz34rNoMZqYoBKJlas6FUW53V21m1bqpNc7vrp8pWV5GSHQ3zlluO/RrBmgSk2i4qhFw9ylWBkxwTUEqwxLbfinBL6zMLjpHSF7UTLvuw3azKJrXip8sez4+o0Cyh9XKbjm6/p394g338UFnk6+dc1PnqvfZ3e71UjpDtsLR3sEh1tupTwtE4XyW19VpSIgch4tMklm35oiWKw5CPlnN2qJAnmSRIplFA1LA0A8NLsFr2hAru8kbZAkuyIt5eUfLkKnNHgCTqmZ9fF5s2ILPm+d78d7I6L2xmXmyORKCh6ApwqbttHRExgklgMer8EyEIIDlAWMrH9qk49Ss4Wmd5diYqW11ax7GYE1zF4iLTPHVOxBoJTOsV85hjEm6wuE2Ht+AtGNcjpseaDiOWMB6IfiFENVOLscMGwxAGlsXw/vwj1gImMIVn3o1v6DrDVw9bsB2exHk2fPwwcLv9Fdv7P8PQ0aeeKP8nQd4i8haR9xB/Q+KNhlrsNbU3QRpGIrOXuWGBoG1x2m439JqmlUBKUp3EInGNrVuvVnFZE1ZUBfhqcZucsKMoFRIz6eLMKiuSJiIgFTavzNP8nVxkOVsozYpRoxyUjFGmMXspbF+MkeR1DwxRGU9T8t0WReRCYaPKSq1gAZOrfK09sS6lel1N49rukkFwDaGV51ha576ymIaUbYIrsIUM/LNDbY5rrAlDqHtoDWtIthnOmSqVEk1gDTEGZl/O3TOAbmVlVpILSZLqAruaBetigpgUpCJY46pfBSJ170yp7H1m3QKy4KpdL2UJ6nzRpEmxeVhpa/PzBdeXM6tkg+2U1CNcDDGpbaTYjiTqOLAy0Z4UZlKciXHBAF22z4wxKe8c1Ts8hVjNASDRDR23r+64e/3Aze0dRixvf3zPu7fvePfuLdvzjr7f5IgAgbdvf2aaJlLyxDhzPB05jydiEpy1zPPM8XCgH3YY27FMi3rSTxPTNOY0ZTEPDOjiVYY3RoOzTo9D0qp9krUck486AkCKOGvYDj0PdzfsbjaMkyVx5nieWRavC9EkTM7IZXPQ3M1my7DZYZyGMuq3G4x1hBCxwefQRoaud3TdoDbDYhsAth4jLtOJGCM9CdtvcYOGA/N+1nzRj5FgYDGPJDkybEbwns3cM1nLbPaEZAnR6JhEkzVcryfZFnVCkIjxGpKpCNGYIiErAjJapN9gjdWA5Plou0Q/EKNrRHwinRISBbOzmVmwbLqefhMRCUznwDR65nEh+EuIYJ3QD6t36jzn0CGtlv2y8leFcl0u6fqOq+9kbbEs5Gp6kscSyhLNAKwRPpcxBrlcpFmwS/3dsrBt/ddj3MqcfNK2DDqK9C6gpiLTLEEbgK/VWT+Xi95JBSdQwfuLvQnFBOICPDYC+yWzhXJ/sYXrNlt2r15z/HFHc+h28b3Sv+2z2s/adl1f7fvr6KfV2F9UqTMiuEQ+StSNI6bieKQHZR6FEOHFPmk2x2ZThWKNp98xVRdS+RMlM5gpNQ7wJa5p6cOXeqaOkL4qY9Zu2rW0tP4VV4cPZeQks2uJZDKYyWCvOFA2Rgt1npdJItc7f+3rDFrKf62nPi0DeBlPtT6gxpS9vG/t1jpbV0VACpBawS/1fVGQFtUYxAIGp85GUV9J3GCSwyaHiZHiTzKNkWCUxbQWuo2C/m33FZ0VxG8I3nKUwPk0cz6MSDzguo8M7pZNvyFVo5MRmEAGhBN9B5uNyllMasTEpaxS73uVwxiQHLM7oaZUBVx+evqm/SliMCaDGFmZ03L0fb3Wa+/W05y1v+tJTznuruCwPE5WUHtlxpK80XjpzTwSKfKLpk7FnKPh+OrkWxnadU7pE6pNpzT4pPRNtQpovlvqW1qd2c3COq/Au7CkKvvX07G8z5WJ2Cj4hdOp8zTP6CKO63egISrSxX4gBo3oGGy9V+//nLtSXnllIVD6NkfnAG1fGZPMcJeUqrUUWcta52Tp75TjoDeKcdOf65iUMpo98TO1vr5+AVglexdGrOswttPFJg5xGzA9Ma05aGNYiP5IDGdSGLGS6K0DJB/Ra2L54EN2spo1+H9KbNjw5rtv+Ob773j1+ivOpzO/+7cf+PnnH/ntD//GdrMnesvpdOL9+/fZKWpmGhNHmzicDpzGE/vdLZthx3Qe+fDhI9vdPc5tGM9nzscjp9OR0/lEDBoeZ9juEAHvZ2JY8NMRJxFxO0iBFHK2jxofLWEN9M4SBFL0DM5wu9vwzVdvePXmgSUMWPeM//Etyzzn43GTnatynE2TuL29Y9jtMH2ntrZdTxg8Yp2aHCwTJZ7bsNnhnKYuvTwtUhZtPD4ynU9sY6TbeTbdPbazTMuZZTpx/DATJBC/OsIwcrM9MoSF8bzDhJ5n+wqfDPMSScGT/IhEg5NIygEGiB7Sgg+CidmbMKnD3JIS0+lMSIkuM8aaPracHYBYSEEyOwg8JfCCe+hw0rHpduwHy2a34Fk4PC0cn1To+/kynFHXGzY7W7PrHGJimi8PPz/dP1dYcw1UU3PH9e0lXqoy22pz3HUWy5pWFS6TgtAK26x1r8K6MedoBPUqYE2tU02JWYVBrJtvrWTThgKHTBX6+bPy/RxcnAyoTZaYLXitQDJ/P8X2nesOgmpZ2ADfihauA+W2grm021qGm1vuv/0THn/73y8gVvFmN9Ies72wEV9dnwOt5dtFQWgzMqXMRuSwoNo/GbD63EpPYkrKkr4EHbX0xomhOCfUf7V1GlJVnbjIbHgEpdsBpBh2XFpymtr4DHqb/kgUm812vujrAgoLQI1xZXZjjhqQfYSBUNuOCDE7i0bTgN3aa6sw0iZXwxINOp5lpuT+i3W+rrA3STnyza0QAAvJVAhLjiJQoZIpwCjbOJbQDXW3z5tpBTRk4KtANfmc/zwabOwwoSMmS8Jg0k6dxKI6qaawkFLgNI2QPE8yYR3cPFg2veP1/Z8qsTEuLMnzGEbOz4GnD5FpNkxieL3/jk3/AFgiA4l3iLwDnoGB7ebX3HKH6+Jq4pH7qmIhKD1INB7BYIZOeyjNCiihgqni9V7npdE43MSUuy/fl51+VwhRxuxy7a6ZrfIsSDHHTS2zp3wsF3KNlKPU1LGEGL1mYZMWCAlFIVPbyggxg/DSrrQ+A6inA9IwiKamt16zP8YQ1yPu6jMQaxml70plJO/XKaPyOuMrqDOIcdm0sFQqq1Ql61SkRkpoRaOKxyLjAwV0J1Kdz0UKF9OU4lkfs9NyTKGuqrZfy+4mSDHPrrI4xRylIe8zNo+JyeNU8ElRPCupI6sJQJXdedhT7ltJBSMVJThebIiFtFInrxJ/5Y9fv8hmdQmBhOFmd8tmo3mNU4R5XrB9ousdRiLJnzDyEdf/TL85sNl5xh6WTF8vfl0K86KM6rTMxJTY39xy/+oVf/YXf8HX33zD6XDg/dv3/PM//yPvP7zn4+PHfMSRjZKtVZsiUJbWL3g/EsNI8I5ghdPpgHWO3e4jy5KYx4lpPDNOI8s803cKqDrnSCjQ8X7h8eMHps2ZGD0xbtltNQrAMGz0SDf6vACSik9jka7H9hvmKDyfPc+HM4fDkeg161fIYUF80OM7IxZjhX6zoR+GatBsJBuHh0WducaxBmsuGb1CjPioMVlTBolR1E3EiNN7/KIg28asSAgmeWChc4AzYBwhdoS4EKJVxhwNiaFpHefMqHpYImGJiAmI8YgL2KShXlPI2p1okOOkVCuaSk+dLfALKScxSMtCWpb8xYhZHNu05/72NX/+67+luzkymx84PAd+/mnh+W3i428958fzxdx8/brnz36z02P4BL/7YeT5aeE0RXwjuFbW/wsnvbSCc92ODepM5YxkJ53srFMwCRn8kOGFSA1XJWKzoCyacnmWZMGYBQKS99iCPi+BamHBSnsS1BiLRX2vsrxA18KY1h1hvaOs8abplI1qvaswCQU4/4Gua/DsZamffkuu3u6GDbtXD/S7PTinYVqy0Nd2roHh26+222dt04t1k4vJUELGtMC4iH4nRflItaLFKcvl3z6L8l6un6+KiSonZTaUTilwO2/IUlwahFgCaNV+bsBcbj+oHfW6LWpbWgyxzkGa8qjzJxJr+WXjjLVGueykTjbK9kL1GK/AND+hKEQFlF+A0LX2yvgV05Trll3ee3klqkOPtLO6Gcr8ZmFsaxl12aS1DnnDXnwgxLlZfwsax1KfVbJtpnyqSNSMe5iAmES3sbjOMPQd1gjjMZCiZzk/67H1PDOfDKfHDpGe/V1iCUcO/veI+4jhrKA5bdE4FD2nc+TpOIEx9ENP8DlaQzLNHG/AerZdFZsQJ9jO5brG7MRpa6ilZipUILb2aXNEXa7inJXBTZUfuRCTGcQkhmSiRj2QNVzfBQPXiKc6V1AlI+UoOSsJ2c6IfLe9UoSLcl1+YhV963gWoFoicKR1XkiW2Qqe9PkxXAutImFSJhEM9RSiroFV9lbn2vZ10jVayKbS32Vv+dT57SWplfI81rUTS6psyacDZfzy/lEJkQLKC1lQWl/Xa9MP+TnKOGdTBGtqHStAl1LHolBc7xuX1Zb6Z8qv8y4qbUzfP379IrA6h0ASw93dA52zGCwxwDTObHYxL9hAWJ4R85Zu+IHN/ond7cLpA0zOEkLEh7keq5/nGe8D4zQh1rK7u+H1N1/zt3/3H7i5uePt797x+x9+4L/8l//E8+HA4XzS+KtBg8yLs6pxiagD2HxiWU4EfyIsBm8Sz4ePLD7g7I7zUW2PlmXhfB6Z5on9pqfrOrqu000padD99+9+ZrMZiMkTwg37/Y7NZsPN/oZ5VrDqnFWNDiEai3QDbrNj9ML8PPPx8cDHj49IACcGbx2klHMOq0e9c5bNbsewGbId6uqlHMOCn0em81GN9uOAXzw+RHxILCHhQyAsM0uEgFKfxjg1r1hmdSzLgDpiMHHBmJnBGegs3nQsJM24FRyhgFXX64IIFmsTzs1MKeDnBdNFjAtIF9XDEFFGIwvHhF3Baog1dFfyE2kZ888C85zBCEhn2Mcbvrv/U/73/+3/4HH5Lf/44cD7x5F//q8z47uR8+8Cx/endXEIfPvNwN/8zY3G2UsQ54jExBwW/PzHkWl73ASfAo4KIGV11FewanCiNo7F2b9QpMU8I2awohmr8u8Si/ACqxZWthzdZdHRetlnYFA9uiuALWA132fWglPd5FMGsKvGniEsV8i2AdGrQKsbmmQQdA1WPxG4awk1M9IfuKrgBvrtltuvvmK4vUFcp0pNzhijW3MOiXTNFnEJXlv72ev7kHWTKL/j1T1F5y/PMZnVDYAjB2dH8yVZYNuMeykk5fE3ZjXfKB+m2u8JIxFJat8ZUrUwZg2W1YKvvM3nfpWcutnkuZKKspPvWaOu5m03KfgOaY0pqTqlZLCq41Cms4KRDFjrszMQL8eiaT2uLo5d7SbWAtJEqvFdWxCrRUnT0qywlaDxmBWMSmk/lbxfp21ZOzmWRGoBRhMKKUZ8WNA879cAW7N6lVSmdehyO+3GYnvLsNnSDY7tsCHFyPFpws9nTk8fiFPAHwNxMfizxXU7JMIUnoj+mY15x+COeiLJDZp61XE4Bj48jmAsw9YxjwsxJGp83ljY1mKzmPvbOsSB7TsFl8ErUHUdxl0fERdwo8kMyMqzhiNURapVlFJNd5693Ks4kBW0oiZthTVbT5rSpR11Ucqv6lBUY1Nl1lpVKWBVaOSXsnZxCVUJ0zEslVMwZBv2ThWPpLY3pBrfutjvq3NvRCNltFNY/ygZrNoMVRf3NQC6VL4q/FU5MLndakytX2nlY1uorC+jllNteMkqS0kogzK9q6PvysReOudl35dMXmiGqlz1DMGN5FNEp87MPuppZg7CWYFts21cdlft7E/flALWjb1UjP7I9QsyWOmR9bARXr15Rd85dr2jG3pcv8H2HbZLJDmwhBNJ3mG7J5yd6YzQiaETo+xfyvavMTHPHh80sPKw2fI3f/d3fP/rP0WS4XQ48W///E/89t/+lcfH9xxP6uB13u2Z/YIYy/7mFjkemcezOmiNCkDnZWKaI9acOI2BYTiwLJHtdo/rBmJMHI7P6jC22YAYusKixFQH11jHbn+jPze3ap8alNlcyYXEsN0w7Lbc3d+xu9mpDS9C1w8Mmx0xh2666XZqjNRp6KrN0GGtYRgGjFGjeAFcp9mfNhFsFCSqN32YZ/w0Mo0npnHDdH7GLzPeT0znJ+bzsx7bJw9hhkWN4YVEt9FnMh9ICWzYkRbP6fyR4+w5jgvjHEl+rgLRT2eOz0/485l5VkP4rk8kF4hmASPYzqCWFAnbWWzX0w2aqrZzW4x1+OmkbOrzgTidSeNE8mFd7QEkCM539NKz3w+cRseYPFMMzD7hl0Sakwa8bK4SccYqksE6wbns0NSupAYgSmvQJld2M+WekubOiDoKNyYANQJAFblAkYFNGSYvTGstxlqs09SqpgCbAoRrZIErxrUBhQWgxsZuugLO1MrVHAZFLkTlCkjTBTKtf5d/y+Z/3R/6Z9lg6uRvyilCN/803a/ALDXMAyDpxRS6ru/Y3d2yvX/F9tXXjE8f8YfHT2RfykNYxF1xZnhJeL6ku682bJ9CacmfmwwcXTNHlBdQsd6C1Y1IqyesLc9dLCKViKjPu2J5Ke3JQ6T5ukt/5t8mbz6ScntXyAdln09UG89UmNNW0ck3prb1kZXxVQYnlPi8KWEiBJNt0zO00C0zahj/xGqeUYBzBod6uroeF6dC4aYCnuP6eX5vtUfMm2gN5Fj6o3S2eXGXLIGsau/meJt1/lFe6wN1LjaVyu1Y7y+DL/T9gOscTgbEC8fnhegD82kkRa8Jbqxgu0DwHrOb8eY9737+F/XH6F9h7Z4hfYutR6ZbYup5uOuxvSOGG0Kw/Pz+LeM0Mo6nnNWwqlEV1AmQxIMVXK9ERUxJA8Zn07Pra2VJpYbcKw41K7hc+09jurJqBg3oTNZkB5+VkVtZuDWUWWUZkQtZcaGsy7rSRNAsXUUmFUBNcdrJ3yHRJjspgFqHcmWFjQjY1d9AI9qsXzCChliKTXSTQrqINHbg5UGrwUxq5Dlova1oohsFpVeyPbc31mgTaX2b1ua1GMBUAwTUNMFRMHq5CqO9glcdhwrCcy9TnGyzrCjjT+nnzMqsKyz337WAawUwpjrvagi6rKpkGaVyJ9ehzIMref2Hri8Gq2Sw6mzHq6/esOkc+96BMSRjcV2H7RMhPePDjxj7Ftc90dlEb4TOGDqxLIQcE1TTqM45iL/pe4btjr/9X/+eP/n+ewTL6fmZ//5P/8gPP/zAx4/v1SFqnjmd7piXhWHouNnfEkPg8GTwwXMaz0zTyDSPhHAixMjuMDJ0W46nE8OwY3dzhzGWw/GJ6Xxi3O+V1c0Lr4DVhNpu7Pc33Nzesb+5JQbPPJ5IMdSJl1Jis9ux3d9w9/DAze0N0xJYfKAbNvRbj5cz0Xs2t7cK7vf3uH7g4fU9xgin52fCshBGja/qrMZQCxFcBBOFKUbm4FkmxzgeGc8942nD4kf8MjGeH5nPB2wImBjBi07QEJAE/WZH7HvCYSAGwYV7wuw5HQcO88RxnJlnQ/QzkiImJvx05unpiThNmoM6GbresJhANDPG9qrxnlXgOmdxQ0c3bHHDlq7fqebsD6RxJj4fiONJbV5bw84CVkPHID03Nxsek2MqYDXkKARz/BSsWnBWqvLorOCcQa5XQcFldXGlvOe1YI2qBavclhwetcRTVS9Um7OKVdCZBculQ/TKyipQdTll7hqQWbJwvnDAysKm1KUAimKTpXZKK1g1VaxmURazsXwGho2Sn+drERQFwMrlDaUPPum+0oH6ibIp1zAvC9YUsthojsXKUVXT98WWqi2nG3p297fsHl6zef0tyzyTMli9fFIGGEXJJKmycD3w1yxwaUEen5dI4TpNClOS20vKQDU/o88tdsBOhGtIUIZSjG7ONvfH6j1c6lgqtdp0poJJy0lbyTYluvmuXvKFUW05VPR4sJSdSYICGFKCEtNU2cPVMaKA44Ta7CZQVkfIGam0/pJy+CQke+YXtggKFRnzvQWsFrMgzS+/ztuSPERBa9moZbWzk7XMihSqliKXoD9rQKstYGlNZu8Ka5fBaZ2fFaxGasOvwz4ZNDFMv9E03PREnziej4SwsEwjzkb2214d0W5njfYyn/GnyNufRoz9NXf397j+hiFZitVzTDckNry+d9zdO/r0DSn0EP4rj8dHCAvep7VNwdRDE/3HI9Zih560GLxXR15n3ItgtUxQEXIWvVUGxYLqa/nN1LoAk4o2jJhajxL9kcfHAAAgAElEQVTOr5WqdeSKwlH6O12W2wLcChfFrmWLMqyKe2IFx1rVa2c0rXyMBVMWQK5py41ZGdUilUwuK1wrkcW05BOwqSYjsSE+ckGYvNbK9DKNLXDK39f5qMmJioNlIU8qmM/PjjXYqcuOYQrfYqlbSqv5RS5flQZDIJDiCj6LQ1gFjBVIJwoYbllPtZOlAavZsj6u/Rc1GHwG9uvCXadotmUtgg3qGH/J9eXMKtDVvS1p7F6rhunJGIzxIE+IvEfkR4x9xlhP13UMvWPTC743xEWwMeAForXsc+74N99+y5tvvuEv/vKveHh4xbsff+Lj+/+Psvf4kiRJ0jt/oqpGnEVERmYW6arqHorB4j38+7s47WWve9oDsPsA9EzTqkoWGRFOjCjZgxJT84waVFs+Tw93N6JU5FNRkU8+8fnjB6bhzNs3b5mtZZwdu+2Oz5/e0fVbttPA8fjEZXjmcolBU9ZZnINpjpmnvDtx0SNoxWQtz6cnQggcT0eCdylVpmI4x4w5bdPElK93r9gfDux2W7bbDdvtluAdjVGM48BsLdo0tP0mAubHzzTG4+yAtB2iDafLmefjM2GekeBppjGKUCVgWzi0NH3Pt99/Fzt8OCLTSPf4OdKFeRKQg8laTvOAN+AnQ5gaLlMfo/znCTuPeDehko8ofo6DwVvwDtP0BG3QuiU4zzzMzDJxPp8Z5zONvaCCxhjLPDtO5yPDeWA6XwjWIS5la2oUiugG0rY72v4A5xP+MiRwvqfbHjDdjq6PfrjnJyDRmsR8i5IjZuIEVBovwmUYeHp+5qd37/g4fIocumFG7QTf8/IyLOn94eSYBs/T08zz0Sa/4C/HsbAIxNX9SqDGAjCUgNJSAHBjFK3WkQGgIvRf6HvWq+e866NKBrIl1apKrgH1d1+svr+wivnydwZ8EbTFRghVtYquybqcKrpcZPFxLUDypVmf61f7ti3C/VqXLVcuWYByW5b61PcPq0/RxUJr2rZl9+oV99//lvn0yPHDj+W6avMz47uyQs/4IuNwqnb4pSOD9pdcFRSxrXSpa7bYLffO9++RL59TkGEsbUjwyCcwH3y1EEn3X1+TBXokIVpohXJygrBwlcoCZOK7K0qRq1/i1xnUFWhe2rAMDZZLAgFxQBBs4r4UcVHBJ3J3n4P20g18fvck6qeAC8sr+MXS6lM0cVT+uSyS6HTWTSpQ/BvyYrG0cp4aoQKqIS0DCrBbV241p5aGZ1G2S9v64BmGM3Y2WDvTNJq3bw9xAeteo9QF3f6Ik5lJnVFhRtsL4+A5HwUjjzx9fEcnit1GoXCI2DSWFZfLxGUeGC8DdhacP7LpPG+/u0enMrkgnGYYZ8vDw+cYqGxdkqUOdNwVjLsHKQ0r66rleRlZAVQCmbrUGRVHkFch+ayu5VvhRQ0s8if1ffAVn3C+JlCA1EpG5oj0DJCqxRJQdriWrfI445TW0QVGScroaCG7HySsmuMDinDMZU1WvsLpmxc2ZQgsICvPvsU1IVosU+ErI0M99LMvOkVshnKnfGKmrkrpVfNiXqdnlEimZf4KFPadWsaXa0v/pD5KeqVs+18t0Nefs2V8aa58FNfSwp8nyR0ng3MQn67NbZO47svMkax7l53Ev8W0+jeBVSMpSlXiADE6cq8FEbTMgEXkM0q9R+kBpR3GdDSmpWtgbi02RIEnEom1N22Hbhp++O0PfP3tt/z2t39H1/f84b/9D97//BNPD5+Yp4n7+3u8h8kFgnc8Pn6kH854O3O+nBnGE5fhxPlyKZWfrWeeZqYpMg+YpsV6x+V8wqbAI6Mjn5hWinEYYqM0DX3fc3N7w35/YLPZstls2G4jXZYxMfvM+XhCaUPbdQynE5fTMyKWab6wuX1Fu91yulw4no9oH6fDxk5oBeHiENsido9RDW+//YamaeByguMzPH3Gh8DkBeOFjYNpchxPZ45d4ONkCFPLMG+jRXa2WBvBatmryIMrg1UdLeFaNXix2MEyhonhMjK5gcYNmGBotIPZMw7PjJeR+TJGQRMEMQmseoX4CFa323vmNjDpmabtafst3WaP6fZ0fYPk4AyX8xEJJbVIHl0p/e4wjBxPJz58/MjD/JlhGJiDRe1AWlkG49XYJMBwcZyeHMej43SyJZFCPkfSfwWMyvomtYExRscni6oCrQWjFY3WNAmsGr1ET2agWpx/imRMq3mRkjhAJeEmKUI1BzVIVbB6BV9v336RhQgoZN6laRbrVhwG63fIQPXfExTXwHSxoiBSOUJmK0Dd0qneFZRddiEKRmKFMPIjSXnmm4btzR13337H57/82+q067+zG4TPivD6vr90JOBXFMqXxVm9L7G2FdOELC3eFYvGUrp6IzqUV4KsBVAtvptXl1d/ZJgb4TIBPJHrUiXwpsrZ6Xllz7uuSbg6K7Z5GT2V9RUWUC7JWpLZEZyKyj6Pe5/BKtH3Fs+qViGoFVi1xZKa2AiS5TVn48ttley1sRXz9E/tFnX5smwqQzIVOvumFtgTqp2AMn3qtqrkUf4/bzNLFRAWQqQ8FJV4tjvuX7+hb1t2sgF5xKofmcVykoGWiQ0D5yHweFYMH584vmu52e9xYY+IR7CpdzTjcOZ4Hvn4cGKcLDc3LZve8Luv7tl0DaCwHt6PcDpfOJ+fmcUxuzSmJPmqpviI6O99NbaS0IzAYVkoq3pnJyQLus9AI5RF57IjlBal1dDKVs98rFwCwiILSs8VoBXzyIWQgtmqrXMREi9w6qacRYnoSx7d8uoRI6syljFdAVWSe8EyO4X1Pv+ib3xIFshAkunZah/bSqmUeTED1as1j6T2jn7A2TKc5hCSfIUz2MsyqVoih+XcaLWWIt997sdKh5T5k7lS8xh/SS7L0m8ZHGfQmqqbXAuWCkVrdrVwyVMl6ZToDrDsYqzUQ6VHvkgC8e8cvxqsaq057PZMzjHbGaMUU9PjfcxmpTcbdm6HqK8RrfH+Aec/M06BaQrMNmA92BTFHkJU9Eob+q7n7//xH/j2+x9o2xY3Wx4+feDx4WPM8CQSt13ajv3NHefTM+//+ifcOPA0e46XEw/Pj9ESOI5sths2fY91jnma4has0tzevmK/v+VB3jMMF7yzaBV9S30QmkTU3xhNaxrC7AjWYgS6puH2Zs9sZ05Hyzxpmtaw2fTs93uEOKDbvsc0Pf3uQH9zQ7/9RNtdcOOId55pdgRmjA546/j5Lz+yfXzizdfforZblA8xWufuwNQaPgahtR43v6X59IlX/3pmN1lu3j9gNxucNoxBMYUG0SOoMUVOx4EdghC8JaRMXUJ0c3DWMk0Dsx8Is0MFYSsabVq22wOn88z58QgaHrFpEmu881iJpNOalrvDG77+zd/TuAYVNO2mozGK/W5Ht7tFiY+pXkMsU3O7R+97/DguVBdaY/Z7Gh1p0ELTYB2Ib9nKa2YltOqJZqMJ9x3dpl2NzWnwnJ4s795NPHyaOZ4dNltdqsm08i+9Osr3FZBVEpPamAqomhQkZVR0BViiXiUJkqvtlETPoc2SAji+kpVV5+904d4FWQRHWBTkFz6HJGCRuXoST3AWSgWWpCjZoKoI4lzZxRSwXm2XdpFFiOZrvnyDJKilum8oZyQftXKL/FlqJ8dFoqmY6GJ7c+D+N7/h3e0duu3xdk7bZWtQWSytFf5+qY9f3ghdlFKJbP5StZdrjZDkRfFuLHf44rkhBUOkQKasoEKaCyFkT5glKh8g0+f44Ne/+aiavCz+oFIqHgpYz+2+WBLrur7UBBlSK3KtJLdstuxL3gyJrggijqBU6XObU6C6NA+yC0JxC4nj1rtIlO6JANUlsOqTa0uoxoJnsc7FiOe1cpUCRlm1fna3zPDShQjznQ9X4yIDmPyMBbaUZ5THLU/Jn+LGkCM4iz1fcE7Qm1tEWnRo0TQEBENLg+FgDP3G8HxreZQj/U5jpEHkgjAQZEvcbrXRYigepTyvb1v225bGROpH4REthhvzW7qNw34dU4T//NM7IixNLjitJjghrJn+Sl2zS1GReyoHz+TFcgZ/MRBJyGAnXiBJPlFaJiyy79oSUIApC0gJ2ToHeCmuUdFRO7mDwAqwwgJ2s9U+A9Asq3LA1GIEUEufRk64qg1S2ap5BCGBs7DYfZKhwbRdXCWpmMnRzTbKgwQofZ7fBeAnzSNVm6/mxNJUGdTn5iqyKLg4JTxx7jlfjB65vLGnQumxrBuc83gnJZmBT7IkB8DlzK6F9qsEayWdWRl3SzlVjMHwPu3u+CSzqMR53fVlCCRdUggAQvX6Xx+/Gqwqpdj0G5giH+qsDdbHTFDTMNJPPd5tooKnxTqNCx5rL8zzGIFqiMLJJRoMUBitaduOb3/zG777/juMNlzGM8enR07PT+XcpmnYbnd89dU3PH7SPPz1D0zWMUwTx/OJ4/MzwzQwzxNb2dL2Pfp8LmU32rDd7rm5ueNyOSXANiUqijgptGnQStGaaD3zzoHzaBFao9luN0yTMF1UsqwZ2rZls9lEYGwtuulQuqHpN3S7PU2/iZypk02UVSlVXOxjTucTw/nMdH6i1QFlOlCC3/XMRvEcFG0QWjRaAvs/asI8cfP5xPmrieeUvtRqEDFEH5rE/BgkOqd7B94Wf0rv4yC24wXrL2miQyuKVhte7ze0KLZGMekYqVyvBp2Lk02JYb+94e2bb7g8nRnOQ2xDDZtNz2a3w9sBO3tymiaz2xAI2LGJeaSdQxlDe/8Kg4I5EIzGeSAYOjnQyYVGKVRrUIeWtlunW52nwHDyfH6Yef9x4jL6QtJeg4hiTa0WidfnQAnoL5H/SqXIfx0t8NltJFpdVUlFCCyO6hkAKVVWt1rphQ2g3vqv3muHfbIRICzgaZnWCagW8BqQKudmEYTxA8kYUZzdl7QtlPNLlHkNRGuAUL6vrw0ZUy9AlazyFgCQlV78sr5+sQeu7ifQbXccXr+h2+/Rpk1bxu4L0ba4BSwBWy+B1XVww7ru2UKelcT1kUtZg0FhyWD18p2zEshg9YVXOmcBalnwL+4eoTit1iC2rli0sEqhlIql9ClyewHpNbDIn7NVVSWwGr9fsURkQBjABY8ScKLSojjPqQSQ0lwwRbVkxZx881zmXszuq4Lz2aKa65+fmTxISxBRdC7xYbHSAUsygVAHuyx26Oh2EV+Lza1qwbC0R+mDFzq11rsFIqSYADdMeBpUr1HBoGhQGEIKwjRotBL2nUKCZ9aXGPAqFmEEuUAYgDZaWiWBVfHcbA23+xaNSU8+o6Rha25oleDvT7SN4cO792RKMhDQaS45+XKA5kVq3q6X6EcoYV3RPKXXvKp5lAmsByLLzF8ecz3t6kh1QnIYEhYrmyS9VW2ll10nFr/SZRegrLIrYFsbEdSykZfpm4rf8rpepd5ZYSSZFQ1rCtM0yfUx4gOfuM18Bf4zaK0XViSLsc/+LWUMJd9zSS4LKXhyGV+1vIht7iNpazHEZDmfXXHyl7E8a1lD3VaFsSHikmXxu4BVyYBbMviOfZF9koOTUk4JeUws86gMi3SvypOiAqy/7vj1AVZEp2MfwFvLHAae3MKQsXeCMT1BFN4Z5jEwTR3n53ccnx8Yhpl5nnE2WtOcjxOq3UZgef/mLbev7vnpLz/x+PkzHz++5+n5Mz7ELAvBOew48PzwgfPTZ/w8olD0XcN59Mx2LqlI52nmfIyBSk3TlgjHpjF0Xct+v6cxkTZBKc1+f5NWrSH5I80oEQ63t9ze3HB72LNpDdPlyGxnwJfOg9gB2c/OWsv8PNOcLki/RRnNZrdhOp9jli7fIx5O4xm8L1tXf/nDH7l7dcc//8u/4C4zf/63f4Om5dvvf8ds4eFpYrh7g/3Hf2b78DM3P/6ezecz+v0jzW6P2u1wQ8c8toTZYYNDSUApX8R2nvRiYpaWYCdwM61u8cHzaWzQozDLiWGacNritUfUMvAjqbJNabQF7x6w818IPCJ6xM4DdhJ647jdGR4/z7gxJoYIYaLpbhCtUXrE+xBXdtog3QEliqaHdn+gbTvsvKVXd8x64LY5cPPVHW/ffMM3X39dxmQI8OHDxP/81xMfP0c2g7JlUwtXiXRT5Z3iolp8nIpFVcWgKqNi5H9rdAwc05pGK5qctSpbR/M2FhWwy9NddEwEoQ0q3acxGqOiz6tWOoHf5PC/LDvjhPc5DWa2yIWo8EMoIOjaMrq855U2CeskZCHZUpcEj08NlAVpRn/ZilJpsC9BWeVkUEmoa+7A1dUF3S4/xl2AVB2JbgrdbsPt23tu3n7D/usfOH38kfHpU9GzuV/zsQ4vui4lC3vLC+dlWqar5cAVrKst9WEB5ERA2Iis7hmtehbnbQm2iFt/eQs8WVarzyFXLid8IIFdcZFbOlkJo9tHbENXBVYt7Sxk4t+opAS8Sm2XlHUOIgp5sRLbIBPyR8tOTjyxbKfHANnoq6qzK0BRdEmJkfOW+9X9vEswVCI4tYHCGR0X2L4snstQSYlFQ0I+OiSgk7ZLVal7WNonl7MAiWjhllLCZTzERASJtSD9y36wizWv6v9KXvgQGGfHzx+e2XQzwbVsusDt4VuC9NjwnLZTFYEWFbZsTODtFlp1SwivQCyEiRDuIHzFfvtE203c9m/w3mCaE6ML9GqHxqTFiwIsWjT75mtc02KaPxKYly1xbSFoRDUvL9RSfXHJSp4WK+XMkHg2KzBPmbbFEYbouqPLmC8rm9xukiPSl75dy+ZFTiISo/FDWDKc1WinLnxaLOV7FhfIIj+THlAUS2QUmYtjTvHxzLeOTuol8ConTIilqIIH0wLXNCZh/ghQ84JSaZ/05SK3va+sl2QarmUey5X8yHPT51VcmtZlDue2zsLQp/kqdcBifM96Je8E6mRsUWlxKV6l5WqK+5f12I/pduPzap9grRVeAi4BVYVKPugpIExJzEwpyVqfYx9CHie//vibMlh54vZXcA7nAxcXIGiCjyZhpTQ+tDgvuNkzD5ppODIOT8kNIPGD+YBLeX5Fa0zbsDvcsN3t+cOPf+LT+w8cj88pZaqP7vUhEtxfjs+MlxPezYiOqUdjAJorpmjrbEq/GjCJ3iGvBoxRdF0bLcCmQytD32/QSpjnkRA81s740LHZbtnstmz7jkZr5mnAuSRU83BPg1kpQRvNNEyM48R2mGjHGSWKtm0RkbglSLQUTNNMcLZwjX368AEh0DQKxsDx0yfa/Z6vb/acZvgwnHG7A/L1N6jpzN3oaE8j5umEb3usabgYg9KG4FQkNy4oJb3yhNA65hv2DryLeYB9w3E0KSBowLoZJ44gvgzMogCsRTXJPhFOOPdACGdE2Zii1noa7di0wrO3kVvVRfJ/Y1qkafHo6GukFGiNNNtIEaUF3W0wpsH4jkZt6PSGjem57+/4fvcbbm9uVmPz+Wh5935imHzKl0xZBeYjrxIzm5XI+ru80quj/7PlVCuVwGX+O5ZTZeoTyZbVyjpXPkdrafZP1TmwSpbtqiWwKllWixUjWZtCBi3VKtmvx+E1SIp4cHlPS+94r8RykFfaoVhUEoipMGVZYldKY22XSkB1reaWcqWvFuwqy1gM1QlVySUEgghN17FB6G/u2Ny+Znx+YCTLucWiW8D9cvdVm+TvryNPpT4n5CCh9T3qI1TX1Ntdofru+ooQHD64Jai8gD5f9ExtOYmuoSHhgmSRJVtaM6gKCSCnAIYrFoBlLBaVnJ6dQaMsEfm5HknPxqvrhccashdrsI+8q7DsROSREZ+e/XACBfgG8F4qsBqVXFmEFZbXBBQLpIjvLtdDRcDpkAKNIVvVFxeNbO3KCwJCgf+JHkwWrtfS5gsor12IJI+NsoCL7z7A7DxPx4Fp8mzaR7zvOOxu8eJwsi2BjIotcEOrHa2eCWEDbAkhup8RtgRu6dqJBo/p3yBhw8n9kdlNdNIRpEFCln8WEUWnb+i0RWsTObUzXBe/yJMXsCq53lWtw9V5eSEegZEUwLKMhwxsqh2SMjEpOmcZV8sIXYFQoWzblzmRbnPN1lKGZQY8SXbJ1Tk1Hoo4SWLyAi+lzmVPrMihWMcFrMZ6FfaOWKDCQqJVymyVCpKZNYS4C3ENVGPBorLJcyb65oaVQLquRwTW6os2qF3CsuW4ZBENmebQL+5qOaBOpLyWPgoJcNZuYAmmF9/SxdUjG3aK3SG1cc5MV/xai/T9chz+wrB88fjVYHW2lvefPjFPI1/r20Q0rNEm0PQKLyeez39GiUZE42ZPmAU7BqbRMc2e2bmYhSkPPlHc373i9Zu3HA439P2G8XTk/PSInUa8takBA0oijdL7zx8ZhxPD+cjh9oa3b28wreAVPHx+5OPDA41p2Gy2iX7DM8+RF/Xx6XMh0CcE7t/c0nc9+75HizDP0SfTmY7Dfs/d3YHDboN4R5hH7DH63I6zZR7nhRtQYvsMlzMPnz9HqietmcYRb6HRbRr0CtO0MdBrvkT/ogDzPPPhp5+Yhgt//sOf6JqGb//Tf0Z3LcY0vNr3vP3hB8bnE49//RlRM89//Te6YaT/f/8729+e0cEzzgMXESaSYE/03rmcmfaj3e9BC9PpgB81jT0yzjPjSTE4y8+f3+OCZbAn5tkyd45go/Awoml0z93thlevtmx3hnn4zOX4xPFzzNRFgOePP2OA48NHzuczQXtU36L7DWI6tGqTIS/6bO42N5GE3E+IagnE7GiRn1bQ9ARaZqRsveZjsoHz6BNH7RpsFXkAaRVZAdXMI6cyaJUi1JSOL2OEtjW0RtM1ybJqchR/pgmpNokzLqgmaA5cyP6rOc1c7QqwYgRAqu2isCiUOpNTsbwtgGRRoqqu/RdWThJwUOJjBpSUz1tn95yUKadQDZGBdL78Gpj+MsDLv8oLZ3xxl9wx6TRjYo6ou6+/5ut/+mem5/ecPvy1XLvcaLlTjYmvBeFiC1oD1fythOxhtlx/XacQcnvI6h5eoj/rags0gPMW7y0Eldo9BbtkcFTAqi/fxfSJnkxQGsQCvizIM7hNyRkLKF1US1SGKgWsxMJIBU6j9XTx+Uu/Uy1gqsYsOJslWCzRvMYiClV7xHNC7stEZJ5jTvJCw/sIGl0ey0XpJpt1oCQDyHZWKX/ZBAoULkhMqIAkXCwLMM0Lg8y0UHhaJTsnlEVCSLtl+YkLeFlAe6g+KfKolrQQ8czzxPvHB57OLadxwrSO7vA9xmi6rsNisDTAiMiAE/A8YsMRF870BBo05/DMxAM3fIMJisenkdke2dz/jDEtSAsoJJyJtFcHRAyNGLxYnGTZ4AhaETqP6PVIzkAjWxVL4FT+22fILhm/LRNCAqH4vyxtVrbgAUnBbD6kjs86Xwkk8Faoo7JtXKreltiXItF6hwiStrS9y1b2uGQMwUdGjExPpSpZkABb9gPIkegqOWNKok/M3MQ5eDGD7Vw70vC0syXvTkny3RSJ8QuSXFy8T/I71WUBzFkxxSUTV3Rii5U3jtHIvlRKkOZABpNV8GPROVmmhNU9EV36RSFl5zDbRKJOTCNaSC65i//skn0vzZMgeFuB8BwjI6CMijt1Ku74OCS59IVCwaeKVTdixV8LWX81WPXecxkH7DQnigwNJvIG6kYIMjFOnzGqw+ge7+MKxqd8uc5HP0Ij0VdCh4ASxW6347A/0PcdjTHM08g0xuCn4B2krBWKaDE9PT8yzwPWxhSgh13H7BynceYyDGQeNWOaouR9CAQL4ziUiRfzuset+65tI+gIHq88QRk2fc9209F1DRI8wYEbx+Sn63HWFsAQiEkOYlasSFW1e36iaVraZotWDSX6Wxu0MQmsRJ+X4D2n4wklwuPDZw43N7z+6ptEIG/YbDe8/e4tT48bBuuQD68YdzvMcEQ/fKa5OyDnOwyZgCPl906CuAx5IS4Wuj5arJse5SIHoHIKOymGOfBpOuGwWInW6WDi5ApOMMaw6Vpubra8fXOLDxbvRuw0Ml1GcoTwcHribBqG8yPTeInBPUYjpkGZBsEk5aIxumHTbBECbvYghhipKQQX0jZCi6AjSfkVgnA+RK7eawC1LA9XIDV/V0BtUrZRbkrZqVCKknVKl61/tfipqnodWglIgVCZKDKIzGwAJSd1RVVVC3pEiuDJN83yMy/ACtIpivUlCFkW3em8/GXaMq0LmBZdtYqu/RajvskBD/GMxT+Kcu113xQNlzVQLUhhVYbl2fEvpQQxms3hwOHNW5rNttT1GkWGL78gW7/yxxpsBL60hIby5DXovL5tXff6HquI2XzHkEFmVi9VWFYpVA3YAgEXo+rJn6MV3RdLjb8yKmUYngNJUvl8BLKqelYBq7m2BajGWpeWzMCxArHleYRkTclyhsWnJo/D0k21Ag2l3C6QfEkzSM+gIJfhi4FUtX7IODiVeUmlGZs4b5HmebIE1ORqFuyVZWQ2fV91e6l9sqiVUoUsT6T87rzjNAyMs8N5RbdpuG0OhLbFmA1KBKcUgk5tN+NkYAwjc5gxeAxgGZk4F9/TaYp85N4fCbQIB8CAeBafyyxf1OLTiY+0UxKWdGylXpXMySAvy8llFFQAdf2ee6KIn/Q527olC4PqmtqXP0P/xbhQNbyQAq+SpS8jq8pVJna9UI+WIuPrXaOruSY61zlTWi3jr8z+qj4reZaAcnyIQ6FjN6T2DGnLO4/96yFcdt1WN72WM8XWGy3BhBQEvsi8csa1yLu677Lbkfu7AsTVk3NbFst5uvEiztLcLc/xZU5noJqmR5SByXrrfR5j66IuY099aS3+d45fDVa7tuH7b7/ifLpE6ykaUR1Bg1WWwVmezyN9r9maRJFkBGMa2sZwDDBZh24ajNK0m5626/j7//Af+M0P39O1PXa2fP70kceHj5H/VCu6za74g3o8tG0BCmZ3oN9suZMGMT3eBy7DhCiFtRNN09KYBqMMPoQIiruOeY7hkfN4YRTo7+4w2vD++REligjZ/MkAACAASURBVL/7/rfcHPbsuoZWwE8TLgQuzmEJDAQm6xinmfFyYTifOR1PPD4dGUdLCIppmBmej0x6QkTTtR1N09Jv+8jpKnFNLGm113VbtGr5+cf3XC6Ww/3X7PY73n7zls2m4/awpTOaVgnH4wcefvdtFDIG7GHHeb/FDmcYLzhrsTZy7QVUEeoi0Qdzuz/Q9h1+vDCeT5G/1nq0E7CO83jCi0M3ydpgYvamRsOb2z3fv/2Br+7v+ebNWz4/Hnl8OqHdH2OWqqSUf/zTn/j4809M6oxTnsAuBZ8ZxDSRMkw0u7anaxru7/bYeebh4wUJnmmMDAoyB3rZ0G++oQ0t4/GCndbhrcVKUOua9F3+PX1VTdjl8+KDI4kBIG7zN42OvKpG0xpD2+gSaFVn/MiGvRXdVC6Gjq+YwSotVlI2q7KyzI71pC3KZCmogWa9XZwBznUjSFXRbCmIFo4lBClv8QaJpNXx6yiAfbYspnvnIIFr2pmQlHRIW4JLOSudtpJQEVCsWyYs6LaSvKut+tRJN69f8+0/Bt79j//Kp7/8mcvpMfpBV8976ZCqjVa8jund1+dWf/t0rVTfL1WRAnIgRtNmuHRtIwgEZjcxuQlytHwGZgkk5Y3+bFmNSskhZP9UIptHcIRCHp8hVFIiuR8SA0iBWCmwxmb1lgEoxK3QEIj+e6oudBlbK0VfAEUCqgknOcljaRlhQLSuVLcrjAgs2DTWO4PYbLXNinIB/pLbXSL4XnZM80NiPXx+YKqqT9vhGRBn2iDvM1PuYmnNCrkAD3J4T/4uA+J0/1R+EV9uIVnXe884jlg7MU8DpmloNwO7neHurqPDsiG7TDimEZ5HhWwecE2DwbKXDcZHQ82rV6+woeUS3jPOI9v292hR6HAPcgPhHmSK7lTGpIxYcVSGIHgXvb5WR2rbEuCpY6YryZVbHKjzhF5fXuRBHjfZ2hlBXwbMdbBT/CL7xS6R50hOLp5vlQCkWoMnlflWfQV6Q6DAmMybmuamSqBUFX/aDN0oILgwCzhHHcgqKTJ/CUyqG05KOd00Q+KpLXSCIY9zH3dVyIG60c3LWYfzDqUl+umWrHHrNs6l0SZSkDnn8g9UIZDUW/jxFqpYkKnOyfpfKRX9fUsfk1Z+ia1DIlBWPu4urnhbc/1CKUpszRQYlhOPSKj8eHPCECpdXRkSfu3xt1FXHbbRWjf5ZBnUBDzOW5yH2UHrITpLC6KjmdwkcmKfBr1ITFfXb7a8en3P/ds3kQrBecbhkvhOI71C0zQx64/RKKujuUtrhAYxDVob2lbYBcVms6HvurjV733qHFPoyVvT0JimOD7beWbOkdo6ZsnQWri9ueGw38UIdCA4j3OOcRpxArOATRm4rHXYOXK5jtNUIuW9c9hpThQkCt32NNpEbtp8JOWvlNCYFqUM58tE009xBd60bA97uq6haTTBGXabjnm/gbsDdA1sOpwWrFb4eSAHEnjn8WpRUBmsigimbVBa0W32hABat2gxkUfVg3MzQcVVfsYZSgnGwHbXcv/qjrubV9zuXjGeFUcEfIt3S5DM6fmZs3jCdoIG2m6zWCRFIcqglKFrO/rW0HcNs0RrUggOO084OyPOY2ho2gaZQtx+qPNMs4iPsqKtZkHZVeHL9/U5y8ozMwDUPqs6MQIUx/TUllmphfpBUPwuF+uFlO0PkSUfdVlhpoJk0ZwFZFgJvwXoFaF69X59ZJtD5lUNsnwuiQEKOKmuy0vlfO8MKliAqrxg5c7yMlz1wxp5pD8KUF1Ke3V2ZAXYbNi/ekV/uKXZHhjHuCjLV1zX/UXwmutbXfNC0X8R+Nb3Xp4ZVnb1a/EbQsAFjwuu3Lk4jFTW0YQeU+t6wJXPIc2HECJlVbSyZhlS9Vuieij9Vu4tqd4LYC2bk4WyKn6f6yRQkUbVIPR6AZJBYah8eGsQQQGQxQeRDKwpyr3afCfTI9UPLwAjg8JU3VzWRXPmzf10VwlXz6i3/ZfAllTgRf1X1VyNr1D9INkSl7et8wiQAiy8B+dn9OywPqCblikIRvLCxENwuDkwTjC2F3TzSCsOjUJJXLRs+gYbOk6XmeAuNPojQSkkNBAMIYx4b2MviEalgCpRMfgn6BC30l86MqATnbgxqfqYIoMWILS6dDmtQi/X69Qim3MLryZZgTH5YeleKVaFHMqYQVkCwmHpK0nuAITrOi7yd1XmsMzX7ApW6P/yWFMLWC0Z9gKUrGhp5eLT7kXByKFUuzSgVOWM2aQs2a9VWP1XplktQ6NfqCAxOnHV8NHNLAHCLNuLe4daZFP6LgP0RcdUI70yhkTGAUGCTmWpz6s/V3Mzn1cpsWV2J30Z1uf/LcevBqtGK97cbdgYwc8GJ4pZtZwvRz58+MhX373h6+9+S99taZsDzs04ZzkcbvFvYuYph0bciCfw6qs33L9+w/d/9zu++e477GQZzxfsMOKto+t3BDx9o9BG0bWGEDSm0ThvsdPIPA5cLpdE/m9RwbFpDaeL5TJP7HZ7+k3PNE5Y6xiGkXl2JTXcx4/vUUrYdh03+wO/++F7Dtsdv/n6DV1jMHjwYINn9o7zNIExSN+hVIyGjewBI8Nw5nw+4ZzHKJ0oo+JzRAW6psW0HcPlhJ0nxuGMc47DzR1N29Fvb2i6nsPXX7O7PaDaDpRmmj3eTczDxPPDAz//2x+wT5+Y377CHQ5wd0sYLrjxgh0vzKKwLjDPkSJLE0AbVNuVYC4dF0Ho5D9rjMGYlp3eYrXloA1aB267FovjGGbaXrPbt7y63/Lq1Z7Jjfzruz/z8OnM48OF0zjEADwPeI9zMxIc4j3SCLo1GDGEaYgUEsrhlebsZ6ZBMY9P2Gni8dMH3NTz14MGNzCPR3b7V3z71Q8MzxeOD8/opn9xjEbhU+bPF9GhlM8Jg+sEUHNUcfLliTyqkZospkeVhV81caxmIZixnr8Cmj45pJsmtm1jWoyJPsjGRFcQk1xCtE7m1yRaQkg+T8XSloRIFVlaAxVJC4oswH0SsBkZSZEffhGmQozcFEGFCDdUUvY+sQTkc33WU5nAOoRK+VQw7WqRUAPZJYNVKXoCUTViyyen+kosb7fboIzmq7//B87HM3/9r/839vJcUkJeA8xw9b78UMOp9e/LgmeBnFK98rkurO+abVgm/bb+OeDsjLNTaa/84OvtxfgWt9R8CabzC4ito4avbxCq4AVZ+qTU0eXv8jVpG68EmmSL7HJKbgOVLelBk527c3kW4BgDVwTBJwXp0xgtmbryk3Kf+azIYgvmbcolVr9aCKhSmNWCYEkD4AuQXFwcaqCskpU6+ws7it9gkFKvBZALheKIOLd1em4G8Rl0Zbow7ZPgSaZ2aaKfqBiLNBOhPWLFcBlbnPZM2jEePePJMYSoE8/qHXb+yN3W0DQG4fcIGzosygd++nTgMuz4y6VDgEP7CiUb4DPD5Dh/vkNE6LuOrmnYH7YYo2g7w+vDntWRLWBSL6IrEJSAa2TYkSUBQybYJwOTzBaRR03IXUWxmlaAcY1RaovqMvDqBQ1pLEmynhPSzT3J0pgBmkIZXcZOofOjtjAuMzv6vjq0UZBiFPAxG2e6A4GUllQSeBOSf78su3ZEo6Sd5yRUVYnLydvdmT6KHEC7GsNpvFTA2jQGgRiEHiCzaWQf3QLJ1QLeiyAsbZ11RewnJToFVMXbeCRZVtOtC6VXDqBK91Z1sgjixJVlli59HgjOxfmd/FghoFXMaheCAp+2/YuvskTl8iuPX8+zKhLJ8huDo0Gh8Ci881zOI84KjTlgdI9Wbcqo6TGmoet6TNuim4bgZ0JwbLYb9jcH9ocD290OP0UH9WiO91GBozBGo43CGCk8lyJxEjlnsdZGH9JEpdI1hnHWqEkSuGhw2qeVRxwokZ4hYKcJ8MzjgOt6bg8HbvYHdpseo4VgI72S9R7rXcy+RfTTRbJwJZn7fZnYMWNEoslQKTdxGlTe2Zg9K0TF2HQdbbeh2x3o+g372zs2h200/UtkDZgJ4GYePz/y6cMHlBvQXYPf9LDfxznsLF7nBAcpat9Hf7IY1KOTBW/xO4zb0rpk8Op0Q68btsZgFBxMw4TCekfbGLbblr5vaduW59PA0/nM8TJwGmLq2SjA4njGeSR4tBeU12jVYHRTJhGJimaaPRYIc7R0T8OZQXtO5xOaCbEjSgm77YEwC+dmjGwGq0NWb9fv5WNWrulLWb3WltWyEpUlilJVr8wAUFbUXFlF0wN1CqjK2/4lkCqtsks6wPQqflPVynRZ8dZ+jYt/ZTFlZA0aQnL9KyhzuSf5nAxCQgGNC8gra+FyXe1DKKs/flnY1IA13ytUl5TA4utbhPRdAg3GaJCW7e0th7df0W62KGPARt/Oa1T6BUhNx+IM8cvnvHS8dG4NXhUR0PgXTooE4T7ioXxdUUD5vKyuM31Ttqlmxod05O4sDbT6qfwS6rZeDci6YItVPN5tfc9sg16Cm2oIGRcSS6yvpDtIudNLbVXGdH7lZ1dVWWzfea4miZXG2mr3JCvx1eokt108P2LmGqjX7+VG5WnLq2jxVT3iI0LsP4luBQuxfCqxCNqA6IBqA8oEdOOSLgjMRJeOyxQYLjEbWFDCPCU2mmaDk4D1R1SY8UGwVrgctxzPwvF5A16Y+zbKFxmZbGAa27iLabao0NLIjsZo+tbQ6HUilVX7Zn3G4tqzLPBjW+TFhKTvVrsU4cv7Lu+L3bSWF7Hf03NXcuC6n6ouLgu0PJlCuU6gZGqKKDtQ6NOqZy3Dpdx0KWGS/0GETMSfYZmUBXR1v9yGSf+Lqvx1USgVCEFHGbVyqapflLaXK9BaIpJSWZcnLm25XL90l0jZ1ac299a6rnxRLXqltFN1Xm3dyb2Zh3oguZmlVs/tG4gGKfL8TTKpnibVM3/t8avBqvOB08VyPE3MwxwBUNNjJ8cwWZCWw+FtXCsFIdgJN8/MzjF4z+wD1ocSFX3/9jXf/vANd7c37DcbHs+P2GHAJZqjuPWv2N3eoLUgWNrg2Gy66As0TgyXgdPpFCezh91ux3Z74Ol44vl4xnQbdNOz392jdcvNbktrDNPxETte6O0Zgue7V6+5f/2aH37zNbvdlkMfCciPk2OaZo5PJ4IxmO0u+mlZx+xmpmkEgX6zY7Md2G4vMR1u6sBxHinBC/KIMZp5ngjB8+r1W0zTsrl5Rbfd8tt/+kdubm/4p3/8Dq0Vwxjv/8ff/57L6cyn9x8ZTs8cP71nvzHc3/b0yeVAi9Bojc5gNMRsLY2KVFa67TCJDkprgw0RWGodOT9brdg1Dd/e3XJvW+5nQWSmbS5M4nmSHt1v6A537Ns32Lnn6fmRP7/7mePnkePjyPkS6+p99HsxQdBo7m9es9nt6N9+j+q3zErhgEHAWsfzxwf8POOHUwTc84xny/Opw8hEEx7x4Z627Wh6i9lsUc06KUCxilJNBEm+qFAspzW2WoAoyVIKykhyd8icqtFtQ6fPxpiUDGLZXikAvVhW84ajgCQ3lmRZbUyL1rEPVMpkFQGsqSIjScow+fiFvEL2xbKaaayWoKwKJNSKI/iVMMnK93+BMZMCCjFpg8jC7QUgAZeEZM7yEpVHTXiSTw+r/ig3r87J26bXICdiDEFQKB05TN/+8AO623B8/xfmaeT86R3zcMLa7I+4vr4G2dHqt0CRUs+6H1O9r4ucFXR95E+ebMFLKUSv2rLw1TtfgFkyktdNmgrso1WiSPyspNJTshUwLwASOFrcCWRROCQKmTzws7W9uscCCzyLt2u1CKp6VCWrjhQtpak0aMxYJVX4WGkIVbVfSIujACqkwLAIfjM1VK2Sl2/UAogWtL/0hOT+zxbV2k0m1n+ZG9FoEc9VhXqwbrcCsiQ/smyEUyLX0ziJFF4SN61FENG0reb+dQ/GEZqBtjHs+o6cGGW4TBzPE8MQGAco2UeGaIgZPvU0tNiTxs3C01kxTsKHz45xEsa5QxA6o1EqoJoBkvHIGOE8eBo98enBksO5/v53N7z9j8uOlEii3ks+ndmIEXIUe7Kk1WBvWbCEwkoSx4BCK5P6PRTQV4Oo3IKS5MnCoLIcWeap3E95nPt4rzWsyuA0ybRsHU2/BwnRCppqJhIZXKKVM/dpypJVjR3J4ySXIQFg5eO4LSwtlTiIBt+oiws7TDZG6DhPFn7VqGOcT0HqVO2U2i4zCWQQWwcIhgpgqxyAJrEQOYWzT4keAlH3KYnxEpK4dAlxKIbEcy6K5N8uaB2vMc3CzRut0AtVVXyPuxXB+TRXU/wNWV9FWswc5Fh6T2rdK2XO/Zrj1/OshhhUNE2WaQoolagyrCX4mNfY6GaRVkmIumSZ9NmCoxRKQde3bDYdjTYoUbh5xk5j9JcMLkZhG0Pb9SgNeMFYV3xYcySac45ADFLpuw1dvwFRcZvJdKBbNv2Ottmw3XS0RqOnC3OwbLsOCYHDdsdhu2O76dl0LVrFrCrOOuxsmea4jdfpGJXnrcV5H7M+hJC2ig3GNEkexYEZaYE8wcM0jTinCsgwpsO0Pabtafstd/evuL07cLjZ4Zzl4eGR8+nEh3fvI1j98IAdz4znM1r3zK5NaWuzMl7E/EphSqJJ0noxv6ftlOh7qdASt723TUOjPdrsQY1o7ZhUZGRQXUvbdXSmgSDM1nEeLlzGiXGacS76CEc9Eqd99E3e0Pc7un6H6jdAYnYIccvAuQk7Ddjzc0z9FwJ21pHzVk0oJryfFx+Zlwb3i+jihZ9lec8YrLak1txzOao2+6eu3jMFFi+B1fzKJMyqsqwu6f8KP2veFsqFytMnKeRQAGulhtPfWXGGShgUJZ0kbzw/V5zi65cm9RqEld9yEFU+b7l+EZZlvY5cm1aox2IGNF+es5ycUcG6DgnNkv2vuu2OwyvH7tU9m9t77OWZ4OL4cHlLq7q+ho5ZWV6XosKMq2t/zXdS/VbE3i/UMxtlYn+mFqz6aNnaj+8vQPerEtQlqqwXV+X64jYINSl6bU//5aPsxyRQt3y/ssJHtJ+N+/F7ySWqIXDqm2TRr2x0L6utQPXQCmUvd/ri9F+sh+S+kFXNr7ep12sTWb2VFs5TK70vdU6URhq8Mmhp0NLig8PZmXnSjBfFPAvOpQs9eG8Se06D+IbpqLGT4vNRMczC05Ho4uXifBhVQKlotRUV0MbgPCgcE45BfKRadYGv36xdp7LlrAahi1jIgJU0Ba/6paxG6jGx9M+LvbgavjVAo/Ablynwi9fLuiuqTlpfkQWdlK6SJONDKXuuBwXArh5Wy0n5sjxfzkYp/4qFnSzf83IngVWjwaXFZHVt4VUutIWpHj71SSrTlScSCaumYofytFh0SZyxUrVfVfK8+CwfVcXHKplyo8jPpX2X560bM7XvVRuv26mSC78OpwJ/i2XVOZ6fjzw+HbmcLUYZ+nZkujzST5/R0zN2OKNNh9EblOlRZsY6z+V8hiB0TYdpNa0W2jb67gUXmIeJ93/9Cw8f3nM5PWLngf7mjm6z4eb1V2gRvB0w7ZlhtHhn6ZLvnyhF23a0mx1fffsd33z/W37/3/8nf/zXPxDaDaHpeXNzz67b8vDpI0/PzzQSaLqGb775DV3b8Lu/+4G7u1v2fYtREKaZeZj4/OGRyVoGN2OUpslbAYm79el4xrk4xLRp6DbbGHBlfQwoMi3D+cQ8jTw+P+Gc4/buNU3bc7w4tLVs3/Rsbw780z98S9c1/OEPf+bHv/7Ef/nf/0/GywltB/a7Hd98823MqtR0iAizHRnngWG8ME4T02xj0FfxQ8qRnmngaUVoDaFrIr2GV+hB442m6XqCdxyGBi+au35H0BfmJuDaidv9GaUDRk94O+CmC/P8zNPxATulvBdGYRqFnaYIOhP5fXfzis39azY3r1Btz4YGD7RMXIYTn/2/4e0RP3yO4EwMbgpMwxEvE/gTx8cnPr57x/k88/R0YRzG1dgUKH64tcq5ko2LbyoRqBqdLKuJHk2nqM5sUW2MotE6pt81OvqfJstq5uLM8zNjpSWfeVwcGB0tq8YYdBOtqdmymiNw4+o7K4wEWENa+WeuzWxh9YlAOkmBEGIUetyJzA0QLaLXMEQl/ytFDgKkrLwhRAd+UZFkXpIlMoCIi0I3qCK3PYKEgNLLU6pdsiIsSwGWyKKiAMMXgowvyrwAncDuZk/bd3z/n/4z7f6Wn/7bgef3P/H55z8xXRYL6yK010fmFa0VnbDmX83fqbrIpT/W1ckgRwCXXutnSlmcxAtDcaSskwJISFbGkMOdStgTOZCn8D+yWGjyy2di+9yvCYgVw1cupzIQZOHALNbMZHVNC6CQAG1sx2QZKTusWQnGjxVjVfxcfFGzslosq9ka5ElpamXpjxwAGI9rJuV8XNF+pfpnHtU6KCyQQVdRjymAKORCVr7cUKxhqa1UeqcAuvi44qtXjZ8IM1xU504xDJ6H9xbRglItAXgfBqyz2HlO9IdC12zpzIYwRz/x47PnPAQuJ7ATTJPGOWEKSb64kAxA0dJubTQQGN+itaYTcHZmGGbcbJmGgWAdfp558wbgN6V9JMm6pW6xf6xzBOcIaTdFJ5erYmXLvZSCj1UCQplfIRQqoi+BSE1xtNBlLQuZ7FpA7qdyXZIZyWdZqWis8um3GIAY8PMcfUa1Sc9XZQco03oFXMlkBnGXNPdnNFyE5ZkBfEplXPMbZ4CbKbBA0KYpvNmZhTeksRn1sc7J2WKiIh1iNk+fFw3EhBkh+ccC2Ud1tvYKGEZ5KNkSmxf5pS2XXbdrt7W88FDJeVUVge5S3yQf1Xxm8rjIPqt5FPiSpSq7YflkrnVko0rJsrUMOrIyzvD8CwXw7xx/k2XVTVN82QBKsEwQLF0rNNpDmBHaxYqUTMXOuQgCTIMGYla1WNgsVMfLhcv5xDTF7ElbYyJPaduhRLC4GJSStmTrqDalFW3Tst3tuH11R7fp41aDVum3hr5LgEFrNAYjmkPXsek6dtvIIqDTVvI0WaYxZqKancMqv5QVQKWtdufxLvLIRhO6iX/noIFqJbjwzUqMus+vxCE3TzPeWd79/IEff3zPn//8I3Yc2JsoPN7c38fyt7HLfPKTsd4mNoYEk9IE0sbEftCRCC6K00hO7nBxgmdi46bB2CYyFSiF7lucDnijkE6Q3qPEoZmxbsKFgRBGXJhjRpVkLY8BSyEp3aSoTQOmWba9afAIyrso4Nwcs1u5OSoQJXHiOEsgUnzM48RwvjBeZuZxWgRMPQeggMfyN9WCslpYZotqti6oMrGrzB5XFtUC+vP56d5FeMtiFfBFWFRE/9lPNbMhZEF9BTwoVahW0i98zlVdv2cLhVRn1XdcbG9hpa2Xc1e+sCS0moDlctf0NMnfL9cVhVPMTKsiVAosjpVrK8EXRyXPtNbQwv7uFeNl5PjuLc5ahtNnIODPlxW9y793S9Kirm7D67/rFlxd+wu3/8JnNYHyYpFIZr1VsFNYAGuGeXmZceXAsYCA6v9rcFz/te6CGlzFfpXrS8PL9QrluvzFC9eXM184ZF2ylauBVNu9V4UJVbPVU/u60LXK+6VuXwUPvdBqq/KUfsvXSanDqh5VA+QdjCznx9EVoOBDwDqPc57ZBnyIHJQqNOjQ4WfBW2EcPOMlcD7H3cvZSiSYT2sH8XmMJJDmXZQjKdDI2wjGrJuw08TlciFYi5snpnl6qVWWVgupvTPACItcXVlK0xgplugKbMrqnqupXq5dFht1p+crczxFsjzU5+Q+kdzuGfRA8c2v5HqoZFeZflUdirUhlAqtW6bMhWpSCCmgrjrCWoeUMpWnLUCxvlSRl2RhNTbjV7neofIGWgohLLpLSv2kzHlJymkJbMtlqqVILc2FaODIK4mqHVaLmUpy5f+WD1/Mq+ujLBrrxlu9//vHrwarWAefnlGnka6/JRCYxwvbveLb373l/usNyBljtvR9j5sGJmViOZxjt9mz22im4QH8hPc2EvvrCCqfn595+PTAp0+f8MHx1fe/Y7fbstvvIDjO7oQSD1gQj+iI9IO3GCXsth2Hmx2393d4LXw6PdFZT9s6wuEGLT1fffWaEF4TxgsKzw/ffMVu07PvWloRGlF4Z/nw/gOn84WPT894JTSHTbRmeo9WiqZtMdMcs145y+UyY72g+w1hdhF4+jN6GnE28qx13YGmFQarGXzg5tUG0/eIKM7HC//l//i/GC4jv//9H3h6PvL504VWQ/96hxbN8ekzm82WtrsnSEyyMDnLYAcu88AwD7jgQWu67YGm39J1BtMYnATO85nzeYZJCH5GQmDrW5SG7atX2L7DXY6Ihs2rG0alOAfLrEfOXNB2pJlGvBtx9oKXT9DOGDEoo9BESq/p5JAwI7pDGs0swoSwQaFFo6WBEJguE+Ppgjs/4s7PhGlAiaJrDL2HborCys5wkgs/q5+YrWeYbaQuupoGi8Uj4r+8okYqP5s0D5WOwsWktKfGxAwfRkfAarQuFlSjKsDKQmeVjzoqFEjbcMQgMKVp2gZtmuiz2rTR0qpNCoxIVGxKL4WWSlCGkLao/EJ0XtV5Ed5SRUrLastodajF8pYFHsSVfO1ML1W7lQADfBE12RMMiK44qW0jjYpaJRe4hnsrwVxk1bJoXVvlWPzi0rVaK7764Ttu37ym7VuePnxg//oNp4cP/PX/+38Yjk/M1i/twAuPy2VJfofuhXPWlrOr36issekZii+ZAuIP2bKaUamKPLZBlfCp+ChFMb3UyoK8AKhAQcjLhbUaqqAoAVV8jVdgIxttEEzJbpUI+l9QN2tKtqovqmujxl5807Jyq8G+pEERkp+d4SogUaLCXOD3GmTEIZm2VMVXtFTwZaGvPqdbaVRJEbtajFSKXankm5eI+5d7LJalWJ5l65oghJQdzEpaYNu5tHMMZhO81zjb4VyLdR1neiT0zFO0ko6jZ7aOYZywzpLd2wjRXjCDMwAAIABJREFUuukT2inJIVwMAgrTjFNCmBsCHucm5mnkcnwkBIf3ltlerprEo3DgpRg5cuOVrWOW+kJmWYgtV8vAusmvYFf8Llk2lyDR5IOffChzkKnPMtZk2ii/LGZr4JzGnCTAqpuUoUlnGRoj3X2pQLo47VxEo+LCbR0S4FwVPtE+ZsuoThmvQj3sc+uU37P1Pt007c/4UPnPSkoHHLJ7l8el5/uyu7KGlnnxlA10WmlERSPd0jPJkpuYB7KVNxCWHaUQErd2BtVLoLI2aXexYoUQQItOQihLyQxYK2kq1Zwvi5cM0hUhWafR8ZkFAK9Gzv/6+JvYADZtxzwFLlrj3MzkRoIS2q3BtMnkrpK/ToqM8y5OXGMalI4Njeg4aJ2L5uSw+LbO1uLxKfjH0BqDD1V6MJIwSWnOsjOxiOCsYxgGpmnE2hmtJpRo7Dxh7UzXb2M5WoMWONzesu1a1DwRnMNOE9ZazpcLl2FgchZB02aBXXwx4t/ee5x1TNMUaZuI7hLW2WjOd45MKyPKoILCq0iKv91HWq1xnBmHkafHJy7nC+/ff2K4DHgXFvoQ55mGgcY01aorCkefMuRY76q0qtnMD0jgPD0jMmEJBB1QOBQKzR0mmOhob+K76JilyioNPjqqW+9ieeyMtwN2Vjg/onRAeYd4V8jvm1YTNi1N22GaFlTcdHbeo5xDTJyg8zAwXy74aYJ5JqT0e5umo9MNJkSrgvUSLRLziHU5x/LahiX5v19QUquvpH5VWaUqn9WiuNI5+VyS0GA12aQ8p1gcAuUeK+tqTduRs3fkwKQ8ySv9u6jV+v3q2V+U58VmKD+s7hnW4GQFhSVHi68BcjkzWcQK3yoZZC2WCMlzpnpf8Nxy35f+qo/1t0LTtYhS7O7uYiKQp69QWtP/5SZSRV0GvKsSK1zdqwZR17XLn/MIq1XyS23lr777su3z4Fg/cYGRYTlvgXZVKStP1Dy2VufVo2H9/WLjWZ+3nHN91GMtvQoiq+/xUj+9tJgKFFBRXfnFk/PweOG3GqssLXf9u5SyLhax67Ou2jJ/XyyECyhYWm956nUvZbAavFS/U/RDVBUSZWiIiQi8N3jbYF2Dcw3ex7zydgJrA9aB8ysnkKRzXME/xScxpIVSRbwed4sT77mbI/dqzqD2pd2/AMc6C1Zsi6teqIEieYm0tGG4Ou/LaxcZVUZDWZgtMzJbTHOGv4SDyJbevK0s1UTNwDrL1iKMpR5pEcDFNK1pnCTe65DaeAGIYTX0Q/4uly2XtrTR4mqQFz25f+qirAgprptoNfAXpZXvpVJAYBmXeVtfLbsSpQ+ra6MMvw5yvZqjSb/pGKVVDDxLcZZ+q+VD7INQnZv7Mnd3GsPVAl7yBK2PX49Vfz1Y3Ww3/Mf/7V94/+mJf333xPEy8Hh5h77tYH9ANh6tW5q2pet7LsfoV3I8n/5/yt70SXLkTPP7uTuuODOzss4+2EMOh7RdaU3S2kr//ZpMJslsv+hYk2xXM5zhcEh2d3UdeUYgAPilD6+7A5FVzSmiLCsjIxCAw4/Xn/d6Xj7cfmSztrRtJ1WYzJroBbBMg6WqPb6q8XVDn6pTNF3Her1mv13jvWU8GkylgICpNKv1GlNpRueYnGNynrc/vuXm/pG3f/6e6TTgbWA8jdy2LdF7vv16zeVuzcvn16xXHetVg4qBu+//xDQMnB7uGaeJtx/eMTrHECKNaWlSFSyclK9z3jMOI6fjkcfDwO1DX2igTv2JoT+VpW+aHdq0KNOAqVjv93SbNf/2v/+3NG3D//If/1c+vv/Ixw+3OCuhAECyvCnG0RLcRJgOxBi5uLqGaDCmBqVxMWKDZwpWiPSnQcrURo9VgSkEfvjhdxzCiaM+4JVj29Z0dccvd/8d62rPVf0ClEGZGm3AaE2lK2rdMoSR4xRhdHC0TNPA0D/Qj4G2CfjQ411P0IZYGa5eX9GYLSFZC+uugxgZhiPWWtqVKBV3f/oz/cMN7vaBYEeiDzTrhu9eSC1tomeKgYmKQGTihNKGFkNJ+pxXgRggUkibLOS8+ZT9qLhHtMok/0ay/5OFNRP+m7R4M7eqVgadCM/KdqWW4nq+h9aGCBhToRKDgKlqtJEys6VylZEfnX6XzbFo3MmiuoBAS8CcrXGzK0jNjSgyJYlaNQtZidkTSRoiC4tXoqPJgDqkDTlZbeHcoqqSSVCH1COpkk8mps7E3TrHn6n8bE/H7nwwl/L0KTjMP9pU1Epz9eol6/2ezX7L6fGBcTxx/+4tH/7wD0ynnilZ55+CyKfw/+kRARXnul8lfvFnTo4JCnxqWZVvz7Wt5ExV/sVZBz6DZWlTX8T3ZgvdrNSoc456lhtuiqNTmtnqJ4AJsvUj7yNLoqscghAW+CXmh8xvpLPTuWXKLdu/zPXOMYG6tHu+D5xXUst9mrblTI9VNtv0zJmbMVuYlSrtPlMZUpufgnWdCf2zxVvNLDUmr6myNhKvZF7fcbZmnR9Lxl0h7A++YpoanDWMY00IGucNwSuC18nQMEiMaAjCE6o1dd1iTIOzA8E7rLXJEFGB0snjIWEAEsfuCi1FLjQQnCPqmCfXJ0AyeollVVWEGIrxB12hyEagPLN1imtHeLtn7EZhVkiJOKpYJBcAT6UZkfo5JnL7OZQgiYekuOtUITAnIfpkwPJ5bzS1zLFk7ZRqU3NsuFJ5NBJIFcsRLj2n1kaqCFZGwiyJ4JeAdsE7XDpM/iuswEa4UOc4WukLZQzBe3ycqRxRmfNC+kUneSthhxKqqJTCRooVFjKAVPhkKfbOoXVA6TqFmOhZaUEUFxEZeX3EAqLzMxRZk4oISGikpm3FWuutT0WFEr9u3nOiLopT3lhV2itjiJJLkTrfaE3UkeCEPpO0lym1WPfl35cfX25Z1ZpuvaI+nPBuwrkJH0fh9KQDLSTzOlWryr0TU+dPdiTEyOZix2rVYZQhhoidLNM4ipNRV8QFOTpRMu9D1hKDI5vxcycLGXBF07Y0XUfbraibJjEGgPMuVZey1FXFerVmt9+xXq/Q0ROclTYMA3acGK3lNI5M3mNRwueYhGuuNJSZCIIPOOeYppG6aVEp4asEgEeSq7cSYn5TUzUC6KV2buR47Dk8HumPPcF7eT6tUbW4TVyyEHnlhTHBTQTfEGNdJn92KWT3kPSVB++IOE7TIwd/5MAjXjlirLFuxaG5g6DY6gu0j4VMXrIRFdqsMdGiY0tEgsQ1MvGM8nSVx1USi2XaBm9q9ptLuvaCyUdxb1RCgSFCwKHthLMON/S4oSdajwqwatZsux37zR6lwbqeGL1sDkF4dSuEuUA/BQ4LMJr3VPXks+Wf2VI6xxppcatkiqv8/TMguLhUfHLtJRhOb0gFFKnyll1OZ+UFVaY3SVAkA4hy+cUyPlvRpXEs4+liPk8tv5Y2kBgTB148s5jOLvYzpFBAbl6H2VqVgVVGlCp1dintmhuSY63Up674846cn+0TAPk5l/p8BaKCqq6JEVbbHVpr9s9fEmPkdH+DqR/wd3d451Opz/MjP8ZfAqz5yDDkc3B1EVH82Wt9Og8/veucU//5z+e7F4h71ppZ2qbNnwKxz1o+23HPW5znzjwD5zOWrSnzqfy1nDuzHXd5xM/+lYBxBuLqycdnXbC04lEMMz+Tc/7Z7pNWLqOxc/lPVbpHL9ahLnRbcQa0cd645aIKzp5fymbGUBOjIYYa7zV2qnFO46whRMn+j4kxRsBq8hYFn2oVSB7EXPxD5GZMjDoqA+LlFFCL8UiFJFBBuPOT6/1zIxFVtsylz7K8K3ONMjn+EqwoFrOFZbGMzkJGZfnwqR9ong/yVlxkoVMsyGcxAeXyyTr4ydNRvFzLsKJZ1ubxjumc8ycqxgi1vGL+WC3m7pzbcJ74OF+qbErLVZ6+E3I7l4Ayr8s471VCLrPcnM7bVNZ+yQrNc/vJ4pq3DySsai7BqhR45RcXTpbsJ1tRVoxL7QyVATColOz5SWwv59eQ54uf2R9+/vhysGoM7XaFutHc3b7nZB9w8YgNlnFUoCOr3TV1tSktil40KWNq7h/vmezEL775D3zz1Tes6ghOcX9zx2lw+KhRdUfVbYjB431gGkcebz/g/cTY3+PGHq08ldGsuxXaaKrGsL245MXXX/Hs5Ruev/6a4zTx9v17ToeBcbD0pxGtR7a7S7766iteffOKbtXy8ONb+r7n/uaO4/09j4dHJm+5nSZ8jFilWRNxbqJuKpqmlmB556RqhfOM48Dh+Miuqll1a4IDFSsmF/EeVLOFTFNV16w2G9qu5f37W5yzfHj3gdubG8bTQIxS8SGTx/sYGQZLNNAoxTSOHB/uMGrLbtcKE4ET4RY8eB+x3uOnAe8miAOhshzsDY/+wCEOOAKjVzT6SBv+mX19S7dfUfsKPzmCVoynCd8Y2s3XuLijU4GqWbMyzzliYRgw7Ym27gmtI1gH7Ihqw4tXv2S7f8HHx0f6YaB/POEmzzg5fHSchgk3jQwP73GHB+Lg6eqOX7/5DZcXF3z31Xc4N3J3+45+1IxhwNiIPw3UtaZrayp9XhRAQSpJh2iTJVzvXIhl4WJ0+jGiBdZVsqxmi2yhp1pkRmY3k/qEJIpz4ZkEqK5QiQnAVE1iATAYLYlvqnCrLgBrue5sXSXOcWL5LH0GVJ8IhQX4y/2REydUQnnZRROCA5UtFEkgxoCOOQFMJ+E3Fy6Y95PlBraMGQ5J4IomnoVxJuxWSWbP4DxvFvPvWYg9AYK5P1JcVl03qdxyhbN7fvU//AeO9/dsrp7z+PEDv/8//xPD4RHvps8KxacsAMv5lN8vvRs/l1D0aZjA8lpls1MIw0KcAX2OK1alpsEceDDbgmcQETECP3OJ1DMFalYspJWi8OcMdwm7yjMsW+zT9+bOPYOyS9wgH6eG6gXgPAPgmX/0SQckT0O+mMalP1Is4PIZyrhnBWhB8l6urcixdrmfYpTKVHN1qc9weJKxqTr3kqR5n+MmTfosqHLXRV9FsVaqhAczcESjYkcMFf60xjnDaTA4D9bGhL1y/0pBGDECy01CSpIN00gMsr/EGKgbkyyVFqIjTFa+06xlj6hy1rtP98igNMiwVxpnXeIud+cdog2YukxSkUPJuoouIG5ekzbJz0yXdwZpya6sXPGMRL+UZaaeh3Hu18RqoNASb5rma3CuGHvEahsSaEqxmGpuR47djHHOoi9x5EYMQjog81YLbZRYV9OsC9mSGdM+kq+bJmZmt0gPrNXsNs/zxxjJY4lR9mDFgvVAqYKz80/JzjegjChCYrQMSXGR9vsqAcq879TVAtPOgD4zAKlsvDMqscjEvLTLGpS9I9NWQl0ndps034Unfa40F+IkayYPcwxFD5btRCWr/iwXSmhTTCwnimToS9bX1BE+BFTwf1ERWh5/HRtAiHjvsHbAuQliwE+B/uCZhsic2ZwHOFUxSBaWEAN13bBaraixKRZD2t60He1qjalqgpVqVuNo6E8QoxM+1Rgx2lAZSRxSWmOMoWlbVpsNddeiKkNA6B6UFoqs9WbNbr9lu9+y2W0l6SUzFTjP4XDk4eHAceiZgqO3VoK9a7EomjTBlVYy500iVDYaU9VUdQtK4ZyXianExePCbH3KZdiyq/fU99hpFG5ZJ6VpJR5HNpaQsvuD9wQtAjqGwDRN2JTd6awhhAZQaGOoqpq6boluImDlWipS6ZYqOqId8SFgAbTmNB2pYsUwHQhRQiJigHEY8MEzVY6oDJv6Oa3eszNvaM2IDkd6+8hhekjE1x70lqhWbDc71usNj8PAaC1NU4t1uVI4D8fDkXE84f1EiA6jDF3TcX39nMuLSy4uLrDTwDQd8QTUQRODIlipjR6qeTHnI7tEsrA6Mzjk1wtsl0HrnJGvPtGWz6woav5+Wg1Prr4EJulahT0gbwKzZXXJBvDUqpr2RJZ3mu9w/mSzB2MB/Ej2swxUZfEmIbeENpGY3aj5hnF5nXTl4kZMDSvma5JG/aQnymeLT/IiXwDrcsuz/89BejljAdrj4ne2DihtMBWstltQistXr6nqhouXr6najoeP7wjezZvZk+b+JVG5eNTPnrd8/s9EBZbvSverZOX+uQsv+kst4xZzwH7aBopl6NzWKdfPd9NkXsc8gbOy8tSOOz/L06c8B835WZc2yjIXP3fB9CUZ9gQsy5u55fP3I2o5Rc6u8dkxUjOYLrPlbF49OZm83iiJz3kjLbHqLKE3PFVR4nLNRQWxIUaDszUhVFir8U4qTon1NKYpnK1UccEMI59bN+GdTR47KAVBSinKePajcmhFKsQgYxtRUfYXkx8QwzREvFOzxW3RG5/t6Py5mufU0y+qjFTK7/xemmdxnitFyVucr5QSaqyErcVymsrTLuf04kIqW7aXLU/XEkq+HGIkco1l8zO3OItQmZA0hqwUL+dYlveokhCYGyLyRs/u9aWsjktF+6lsW/ZxXkXzO58VB8sTVA41WPR9Gav5RW53blqWN2rR99lgs/Qm5n0i3zPf59z7lq336bpJNhfDRZxbVZ5Ozdc6263U8gm+7PhisBpCpO9H+tOJYbjH2gEVI6cbzw9M7Dee6NJkRRFDSIlGoWgitTFst1suLq9Q4xFDRFc1pmm4fvWaerVmtVpxCpb7h1vG8ZFhatBGUVUQlKZrN4Q4sTpFYqKnWu/2XL96DVXNYei5e3zk5u6GZ/tnXF7s+Ztf/YIXr17z7a9/wcuv36CdxPTYyXE6jfzpTz/y8cMHbBVwRB4nh6krrp+1aF3RbnY0bYtJdBemqmm7hna9Yh01lzRYZzk8PhC8JgbNYD2j9XTGUytPq5TEs0QB0oef7hhOPfb0SHQ90zTJpK0bjAloZ1A6YONIrSuMqQnBcXy8R2tP22lqE9hupPJR161hp6hNy4HAEAOm7qCGS9Wg/cDt8PeMk5TGdcpxEz8yVieu9CUrtWbDiugDjze3uMox9COr7SVfv/r3XGxf8ub6bzkeD9zd3/Dx7j3vbn8UKjIFUTdEVdFePMd0G24e7tHAdrdBK01oVkzO8/H/+YnHxxusPxKxrLoVzy6f8d/+N/+Oy8sLnl9fcRp6qpVGf/jADzc3eC/sAcpX6Djh7Dl1lTGapq7E4p0y28tGBMUjkmtg53KnhfifJ4UBtEm8cgoy2CRvZEt4km9ADmyUKioqKTha6LoqI+OnTS0WV51Lrxoyox1kTHYuAGIS9qrsS+f3VtmSkZHjwr5UWAEWYaPpoxmwwhz2EVMd7CSHtQ7EoAlSnwelwwI4MV8M2RjzX7AQSGebe8HD5cy4+C8ml6i0bwasOdQlZMtD/jsLUiXK2u76OZuLK7YXlwzHI6ZbcffTD/zD//4fGfsD45QAwaKdPHktPfjks2S5eGqvyxg825jHMxh4fpT63WggEHTaKDMBeJwzk/PuETITg1KoKBWKzvo+J/nE0uPJgpEsblFiVkmxq7IOIpJdHmZjiIIyScrTnP/M+2YUqxv52vnOsVxm2W+ygWVwKvbPFBBarpgtdvP8zPGSkWwxlU3z0wz0qBQhW5uLZW2plGSQSvIYZN7NLBdkfZu8caevJANqysCfIVRea4GWGCu82+Ks5vFOwKeLuXCHSu3wZEUvFbBiGh3TYLE+/Yw93o5UjcS0t21LVRlCmIr7W6HmDH2VqaoSWKsS4DaKyhjWbY2uFHWnOT7cEcORqv509qpk3ZaZmWe9SXMuxYOmPS/3qVSJEgVR5p70iz4DkslNHINUMRLS7zRflWSFx0pG1kuIVwxQ6VoMLCk5W2cZGBLQjJmRQeaPrsR9bSrDshz1chYro+Z4ywyOQ8QHtwB9C+C3/K3KrC5gWYo9CDVkJMW4As6FknAdU8JbNhYs41ClXwRQh6Wcl05M+0FYINi0ByglCdaqiMXSUJWSvJaGFgGqs7yVfU/CEgsTjlYplFKJhzbO1uUci+x9cf2koZU+9tnTkpQrYTtIp2S5lnsvAXxCnr/LNs0+xX/t+HLqKiJKW9o28OpFzTglig2tGE8RO5EWaCyVpZyzTNPEOAxSJalpqSqpmWsqycivKk1VG3ZNg1KR3W6HJlA3HaYWV4cxQjiPiRhqQqxoGitJIUbTNh3rbi1JUf2J/XrDt998y+uXb7i+uubbX3zHs+cv2F/uqZtasv6niePjgYf7B+4Oj9z3B0JrROPL2pPRZ8HbuiCGvDhlQsUI0zjR9wdiMMRgmKy45mMiWfbW4pRiTOu2f7wvBQO8s7Jg00DngOWIJ2pPzBtZchH5/ON9col6QvToCLWpaNu1NLKCaCJtgI4KQy2bno84FRmcRTNytAdQkZamTJsQAoM9oe0K74JU8pomhqHneLxjGg9iwV1M7KyoGKUlQcxUVHWD1hW6W2F8oGoqKV9aGVQwdKahaSqxfHkvAlkrojZ4pZlI1uxAYgWwM5dmOrQSV0YIsnEVrZqsSSY8ubBkPrWoLo950bEQfLEgPlWuzQIQz+CxxKTqVD1Mm9mSqhf3Z/691LyL5XApJZ5g5J9bo6Xhn/na0/cKoMjWEDULOPX0+zG7whYZ1eVD9eTkp/15RkhUzj2DQUurxBOwGhJ915nlolhb50NLhQfqriMCly9fohVcvfmG4/0t/v1PeO/x3pfnfwpcefp3nB8rx64uz8t0T7IpfXqtuQ+y6I7ly58OsfrkG3Lv2WP16VXn/l3G4mVfXUQlI3dibVAg/LZijcsbYm5BBuBPb6cgWZnm9i/Pma2nc7vlnlnhSkB1+eAZwKv5Sc6mVX66AuBnuqtlW/M8nn/nM857af4/ZqRa1vHSYFXkBmK1A12S1yWDX+NdTQxSDtU7yLgsILLT+6k8W+5i5xx2nLDWSxEXZ3He4t2I9yMmKJRRQIobzG79BJxNlZKcjIxtCBQAKECqoq4q2mZF3Vas9iuaqkarwHa3/8z8eTKOeUjOO+Ks5+YhnifuPPTpw2zZ/QRUpc/yNURzQBS1xbrPX9Ey9wOZsWAR13q2WhY3UmrxOHnxzoMg7vMZMC1lal6d876hZi9IsmqWyk55fpiFl24JfNP3SmGK5YZR7qPO7611qeYVzwYmg7w8Z5fW5+VDcCYbS58vniedlACmMO6U+2Wgn8MKoCgtZ2t24S3IlIrnkng5Hpy/jp90+xcfXwxWlQ7UzcD1ted/+h8vOB5r3n9w/HQb+d33nqGPRKT2bnCOaRzojz0P9/fc3nzkxfVz9vsdXWUwONpVQ13VdKua1bpie/WcYdzz9dff8HC/ZbtZUVWapjFUWtE1RixgEdr2yDgFPBCMZrff8+zyGTfv3vPw4YZfff0N37z5ml//5jd8/c03XD27Yr1e40aLnxx3H2/pHx754V/+xNsff+SP737g9uGOeruhahouLy5p21b4VCvJutepGlEKHBPXdooZddbxeH/Lh/dvibGGWFM3G6qqw9cTRsF4jEyD4fQAMXgOtz8xDEf6R2Eg8C6C0gRTy2QMwrvmlZMs3ihUWNPoGYeK6TTiR0t0SCjBNAkbQ11TXb4goBisxTrPTh8wtqdlhQmPTMEKVyEjkwu8V28ZzI5Vs6VWkggW4sjD6QanYPt4R7QK7Vo+3v7A929/l9yqDqVrlKpRZgsaml1AR6iamqZraZoNpqpZbfa4EFjvd1g7ou9XqLriolqxXnc83N6giVxfX+F8YPRwCnCImoaIiRAnh5sOTNM5wXVlhJ/Vez9X/2COL8pWmypl0uas/+Umld1FmVdS7A6iFfsYMQmsZSvWGQBeCLEotmbpF50ZADILQALxiWM1Z7PO+0BcALIc0rAQWmcr+1NEUQBYtpDF5ScL4ciTfaQA1TgHzafrqHSdQEQFiQeeLVxqjqFMt3kqfPJGGsrfzEB18Zz5uZ9aVmNym4YlWA2L1/JlirKkFXXbYuqaX/ybf0P/9TeEELl7+z3/8J/+Z8ZTzzSkxJZFfz0VtZ+A0rzpPHlf6rXI5+5zIjuNr1LzFhQT72bxQOb+QJWMaIUu4K6Q1iw6OS4UntKu9F+uVEWUsQzpd56zQef3xcq7tA4vvKJls1MoopLkz6Ks5MmVJ4x6ao/OlOd5DhWz1uK8MHPIKnlmnlqGIHFXKqkOl6w6gRkIZD7OHNt4TtMkVtsCdFRuVQapUrI0u0kLn3KhlqsBjR81wWv81OGDwY6K6CN+8qlwj2zi3otB4dj3Ep5SN9KD2jAcTxzuPwqYDZLFH4PHh0m4r1sjHJrBEnFkU6BSFUppuraVDOxkFHJBlI6YvEFt1dK1HfvtBev9juuvXuHDgJ0eefPqgrMjRlRIXKeqOIbmuZpooLK1ec7qlgmriIU9hNznURU2lCJco5othmVs06TP8i9koKoWfNJi0EJpVOrbGAKfHosqShlkaQnDm5UcKZYwu+hDCckrlsc01/O81zrH71IWhFIzUwFQrLrijgIfNUFB0AHlk8wKMeVB6LJHZLrOmEG0yXMveY0Sf25mKsjelpwENUP6vC9kI2GSl84XbnBULmqTQhcSnZnLa4darpt2j5CqgeVqhSbRZUoOTN5DdBozSebOfVSALrNFtSikWV4sLENZtnzp8cVg1RjYbMUN0DhD1Bp9I+59k62OyEC4YCWwO1FyRGJy1dYYFSAKfynAcDoRtWZ79Zy6rrm8ek5VNXRNjTGKplYYDU0t9oUqPfN2s2Hyjt45gvMMxx43TRACTdXSdA21riCEZPY28uUI42Q5Hnref3jPu/c/0Z96RjsRXSuLN5ns62QBNJluSOcBFd7QyQbGaWI4HRlOJ4ZhQDjxhNBZLK4aEjGzNkasqM7xeHgQBgLrpBJWLqMZpLJUDEL/IPRB83QQ66pnHCe8D8WdHcgxkTKkMQpBvQuR6MS62yhNZwwWRyDiIqgQONoRE2tc5YS2ytToWCXAHJmcxYwjR3XEOqibPafhnt4+UFc1tanRdGjATRPDcELFSG2EJ9dUFW0FlYeksvYEAAAgAElEQVSuMti2Znd1hXaWhkhbK072kWassM4SfMSYGqPFEiwGM0Nwgcn5VG5weSwzpNXybREwatYsn8bP5H7NQe6iRKbFFZbgUQCJjmLpK6EG861mQZ+E+Fy1ag47yGTNyyzW880/L+zPwKcsfOd30vuz0D2zeBTrxl8jEs7u+Clwi+fK/CeQ+VMMXUAF6vwx582PRT/PG+I5GEnCmMXn6X6fWKGhWJqaruXy5Su0gutvf0n/cMfd2x8licVOCValdf0zz//08f7S30+PvPnF8vei7T9zfhnh9OXl3JY2pU01u+HVQhlZgL8yQzJDUxDoqFK/6nKtgpZz75092Vlbc7NyskT+PJ5/c95O43z9csZ8nBGiLQCD+uTUtC7SnD6b7gvcfN7gufSnOvvgXFYsFUJF5j6u0RiCEzloRwheuExDCEI95SPWBQGoXpRacWkHNJKVH1xSvqLCjkfseJTxTJt4pjyKphaLd0ilTuNc7c5UNVob6qYR70Gp7ZzabSRsSUHyagaJ8Z8CxtQ0q0uapjvvd5XoqIq3MHkPC2uJLuMxg42FNbO8iOVXAbsxT02VxuDJmKt0pcINmq14KdQhLBS0/AUkfnTx55mHqiggLOZeEWALW3suSlCAFEkuLZP6VFLkZiVbp5AJnUq5RrQwITkvyk1M3kWtpJy5Foe+Z94TijX/bOPIgnQh+/JHyUXuUyjlWZNVAo1poYjC7VPYSuo9tRyfQE56FWUjPXeYixRnsFlCKlAJMS/3lHRuUi6F23ZmDCi662KcZtaNPObL+fPlxxeD1bqGF69hGBWjr6AyxD/KpO+MZGgrDM4GrBM6KmcnQpCtoG1r1usWozy4E5iaGAK3H26oDkeevfmGpu349rtfM/QndHAoFWnqiFZS7lMTqaNns2ohOu6PPcPdHeNp4Obde6bhBD7QrVrazQXYyPH2gf1uT9hEqkaqLT0+Hnn37iN//4+/4/s//ZHbhzsmZ4l1DVHqKxNa2kbKtNZ1Q1XXkl0YA856Jus5nhyPjwfub97zcH/H4XAgRrGseedomhXBjYx1RdvWGK04HB6YpomHhyN2ckxONDAfJSEs+AoVNV5FTEUpboQS4Oh9YBwnDoceO3lqVcvs0DFxudbiLg+B0XrGaWIaRrwbWCuDrxpOWHwMjEE4Wm/8I66KfFWPGG3YNltssChX4QP04wk7aqbHCl037C9/Sf/hH/jY/xP7Vc3O1Gg2KKU4nY6cpgmUpmtaVq1Ye9dVJCjPZVfRbta82v0NJlqOwzu8D9z2bwnGcjr9iqg0q3ZDVx+ooqHWFW3dcXInTsMj9knMqlhB9bypq7xYVfI0pbjUHDqV1nkWa5KPKn+JFSplnqbMSB8CPih8kFg/WWxCOVC097IuFWKJl5hVrSthADh7neisltInb+jhcxaoWSidg+yylcygbQF2ZwAwy4ZiKcv3ZNGEJ8dsFVsgUJXc4fH8e1nQZQvF8hrlTgVYciacsyKwtJpma4koaCElqpwD1XKpZRlKKM9vjKZbr/nmt7+lf/MGVdXcvf2B343/G2N/IN5bfLImhyLw//VjCeV+LqmqnKiiKJ+pXSGGs3vEs5Nzj6XdHk1cANKcw56fM3tb8/SQulAqcWIqhAUgtSFGlAoJsOo8YmIJylpEzGBxBnelV1UCddkKpt0C5MqcFyu6Lt8ssDpPybI+86sUN5lgRmLZTF6fuVcCsexxMT1PDnuNLNhVz8CqQieDyIyrAjnj/GxVZBCMQqkKrWpMXKNCjevBWegHlyyZYvXyKZzqlIwG1iXOUyQuutYSi2nT59PkGU8HhuMtumowtXjtqqoC3aas/0gIUxoKg6k6KXbRbaiqirrJNICSLV+lct1VUxF9ZDoMBOcZhwmjB4bbE9uLLZdX16xbz7JWm9YGU7Wl37RKsfSmnsPdUMVqneWKzoOXwX12CyS0mq2Vs7wxZ8CkKA8KopL5LQW61FzoZyG/xCqdZ0h6P/E/Z6UfdKHoiqlNIvd1aVok0zp6wSQFbCVAmOeWFnYHF0yZWwCNcaA0pmoAzeTF02ntCa00TSprLnV8ZO75tA4ys0rpuuTZyB6q7DViwQQg15I26JCrbmWQqtLzm9KXIVGeqZBYiFRWCrLcRFZS2l+MSWMVwlniaUzhiBIeoMqcUVkGFC9FlH1OVWluLDiOyz6UmUuWg6+K0Q9FUUC+5PjyMABT0a5fELXCDQdQitE+YANSaSmR2PsobhDnPM45jDF0bSdgNkJwDjdNjLFHa8vACTO2nE49MW3yVd1gaNAa2iaiVcToDFYdmIoLH6nWI3R7tvsLoq6wHvrB4sKRcQgYPBrH6fBI01RUTQvAaC3DNHGaBkY/cbnfiVacWAaqqqKua7quo2layU+IAe8mfEocc3bCuxNuGpjGE86OKaHMQ9RSSlYlSohYUVUiKCc7ME6jxJ6GsIhzEzdKDF5oU4InkuM/VSFbBtHsJ2sJPoAS2g4XAn6c8FgmL0wE4zBg7UicRrS3XNR72toQbMPJT3wYDoQQGKNnwuOjlyBrrTE0NGZH1+zZbZ6zaS95tn5D3bU06xXtyuHjgUaP1GpEYVBEpsnilKPZXGKajnVbU1WKJt7h/Ym9OdG2gRf7FxAdw8cH3DQwnHpq13Do76mbjvV6xX674fnFFZXWrJtaqFqMpu26T+cn2XWXraez9fPMqkrBEGSAGINs2ihxB4UQhUBIxULl4VXEaxmjIgzT3FcxCKhIQY1n1tXyk90yfILy8qb/NPJn8XDniDO/GfNGvQCAGaQ++Xq2Xizfi+rpmU+OuHiRNeQFbs33nC+qzr66rCBVTlOLP5aANbuwnlhRzwDqAtxCPLfOLsFq6U9pkzaGpuu4ev0aUxsOt7+lv7/j5sc/Y8eBoT/ighBhh58BrAUgLrol/szrz3QgMS4tFEuIGs9CL2YYGcurT1K7FgrIMl5OF8A4u9eiAp1DAshZ08ltnoCGjin3QZ23Lz55oEUKBaDmNaTytn6uSn36avlXgS1kFSpvvJ8qZfnuSalM8yws4iKz/hkzil9YcJ4unfM1kiiTYg3UeNsQqHFeJx5w8C7RKCWWlswiIzRDwoqjUkBIcFZCQrzkbVg74n1OvLEpoQWxokaXqk+R4ijl+bQWnnDhEq/QKkL02FGAsLMuzXmpOhjpIARCsEQ84whER6UUdjri3cA2ruB6O3eC1qiqmkfC5MSm5bh8Oqdzgtm5dTCdn/INCnHIkyuos4HIQCYrCfO5KsmaHJqR26L1EijNVy/rwOgyaVWSsyrpYSrMMlmrWDxfKlmDpnHCOs9oR0n2alpx89diZNK1JCU1tca5wNSfSsVNrRRWC0LMSbxVqo6lElhdbN9Fjs0YLiNRSWItczjJBXWmqc19GGMObUnMwCaZXKIvVvlZdueZL4MjgDaCmQ01LGVrXifpHtkLOFfeOZd4+RazlyuWf4sdisLDWqpYaD6dZZ8//oowgI7N5a9Qxz2jnwiq5TjeMziPNx60xNs4JATA2knI8k3FfrujqSpUDLhpZBx67GmCqLmzAVW3fHt3X0j0m7qlblqMUXSdxmiolRcLK47WBZrtMyYfuLZ5cwuc7IG7xxHtTygfYboGuxdLrHesdhcoU3EcBg7jyGHsGd3I169fUVUV7+4fQGnatqXtOja7HavNOnF4erFQxiAFA6YjfnjEnh4Yjw+MwxE7DeR4tFypIwaLqwx1swY0p9OB0zAwWi3Zodl9kDSYEFKmp4ZcqcqkSkchBJSfy8pa59HKECJMLtCPA6fJ4kLEE3CjJG8xHTHR8ubiFdSwHT9ysEcejv9Mb0dOIVAHzxQcLnqUqqh0x6Z5wWZ1zYtnv+Lls9f8+rvfsFp3bHYrfvf7C1ZNx3D4nvH4I9Y2OOvl2Vxkf/GK7e6KTeuptSU8/oCzd7ysDvhNw3fffYeP8H56y+nR8hjvCJPjw/2PXO6v+ebFC2KI/PLNt2JlU7B2E+tpZLPbnc3NrLnmeNQMVHPWb4n1UVkGnLvfY5CI+6hMqpOda1LLF5yT+CcZEiXZrCluWarhCAMEOuvKizCANHa5lG1Z9OlYbukxLpd1frhZS1Znby5BbrpSBm15o8iCPocsLK6R5WG53s/8zNcWDfmc4ZYCspebVxbSMfUvEXzMrr5zoOrT7+CFK9IvFIjsssvXnGNVKdcoIHbZc2coSzJeu82ar/72b7l6/ZrVds/9+5+o/8t/5nj7kdvv/yglk73HK1XiuZ485mctr/+6mM3Pkeq4F0tU+iwTrWaAGZfAOMctz4OXN2fITm5F5sfUWgqy6CflM1ES4qITp2RApbhJUEFcjAICF9vUWTsXQDUmu2umVTIZhOeNMYGFPMxP+0JlUDv/ZD7YbPDUee0lkJ0trVHNVuW4IHPPV5ozwWfWhAxi51UfiQSpIxbFGxMxKFYQVripwTuDHT3epdhSYrE2hlQMxo6jWKT8hIpiGPExEKzFec8wSRicncS76JJcr+sqJZB6YnRYO6/bqpKqd1pvqJqKtm2lWlO0RG8Z+gPeOU6DcLVWusNUFV1IFlM/govY8cCgKk4Pt5IX8kPLTn0Lv/pNGQllKlTdFv7MpYBcSqgZEuYVluXJQq7kOapyVaU4Fy5bACylJAlS5EISRvE8HEqVa2WApAo7wJJnfh7dWckxRs/eJQVK6TI/QgigQuGU1lXycJkalOE49PSngZuP9zjr2F3saZqG3W5D28p+2NSGVasYouN4/xHnI1Y1WcQla3VN29RsVjUSYCRWUZN403PytIT9yVrQuk77VxBmi9LNCQKm9ZD3qQzaQ/QCqKVjMRgh9SfKelqwBMSYLf8pYbWE8cimFYq7P8v9FC8dRbabSqd2zFy+WT+JMb89y+PZuDCzBsxyJZlYYoC/7Js6O74YrFpr+enHn7Cux1TPuHi25d/++xfcPZy4ePfIy9dvygTRlQAw5x3OO9E+tKZrGvAedxrojyesDZzqPbpV/PlPf2Z1e4sfA1oZ9hdXxKA5eiQIfTpRGUXXVVjr6fuBYZx47HuG4UR/PIANROvpVi2btmGz7Vi1LYSAHQfW+wvqpqZdd3S7Nd16zWq15mK/pzKGu/5EiAiPqzESi0suPQch+iSALM7aNPhLR+dC40suB+csMXiOR48yimE6SVxmrJlDkQWsRoSoXZIrpC/bpqZJVa+EXWGUzyP4EBmdY7SWcRoZhkFiWVNllOgtKni61Yq63nD16jlVW1HfrXgYHvjp8MBBn7ATtHoFdEQafABTdVxvv2N7cc2LF7/g2dUVu4stSoGdRoKbIExEN+CnHuVrKgzbrmOlGr5++ZLL6xfgDkTX8/AYwVs2XUeko2lrbIgYIwUTNtsttap57D+CCqzvdvS9RVVaNhWlaCpFvTK0XXM2NyX5TeOSVps3yDOKGpVzqmfxm9Z+WZ4xxORSiYk2BREOKe45BKHR8aTEg7DYezWivceYBPTPAMAlAMjgBfneU101tztvIHPYQKFdzld6oqkvge0MfWTjz9nDAkCK0M9A9rPoawYhWdsuaLhAUzKmLQC1PG5qQmTW3JeWUqnis7Sksvg837XIQrIFuYA/zs87A6v5pRKXad007J5dYyqDtyPHuxtWmy3jMHA69YzDQD+cGE89Y3/8XE/8VUdUyWq/iCVb2JsXSkWyiqfxlWmVAf7iXPKcoISSmJQMYvRMdUXpj3lbj4qFIWN2wquFy+7TJ4zp3lm+nc+8GQpmcDE/9yeXUnzmDQUp434+RVEGHIplabY66wI5SX0mfaoX1vxzhaWAqmzBokLoUlqILd41RF/jrBK2FO+lCmCi6PLBJYvqRPSS7e+9hFmFEPFBElN8ss6rSouxsmpLGyQD25ewkLlKlRxNK+Cz7VqqqkIrh8ZTNxNKBYwKeCcGjhASyNMQ3ERVadpNCzFKkZYIMU6E6HHe4cP4pOezO/Z8WNTTN9K5uSpjyQ7PYz2LoCJAzkTD/EGBvEXeFEvp+X3Lks2XjudW+wxm89lzhbonbcoWVKUwwYjcCDIOKtFebi/31F3HCY06njBNS/CeNllUjY6o6FMuWMRaj508znucB69i4XsHJESDGmVq6eOoi4KuUUSd6ND0LKUz45BRad9JsjLLQJUKcRSHVBa0C+tmXn86tSXmNZQVASWLP2o9j0aBK2qWKSU0YVYGy4szyrm8Zwn4jgnslnCG5e84t7EsbRby/AuPLwarw2nkn//pD5jK8O2vfsmLN3u++u1X3Nzc8Yc//Jnt9ko6ywjHZCRg3chopYRpVRnWXYtyjul45Kfvv+fQD+jrv8OsNH//X/+BpqvZbzesuo5VV+NNxWkQyqSHuxvqpuLy+hI7OQ73B46HR24+vuf29iPv3v7Iq+cv+Orla9bPtrx8eclut2ezXkHwTH0vyWGrhs3llm2/Y7vbM/ZHnl9fY7Tmp7s7rA+SUV/XZRPwPiQw43HWMpxOojFnYbNYOCrNgBATUPUOrxQnawkEhnES933p/iyCs+VlIiCCQeuK1apj1XW0qxUMpCxH2TqsD/STox9G+r6nP/WchlOJ4asIGK3YXb9gu9vxN9/9ltV6zeb7PXePN9w+HrjvD9wGR2M6lN4RaXEOunbL9ctfs3/2nG9+8Xfsdx1Xz7f0hwMPd7fYoQd3IowHfP8gXKK6Yr29olpf8Xff/YIXr95wf/OW0/GO47tA9I6LzSXKbAVw+kBVdzTthovrZ4TJcnP3I6fpMSW6tahqg0IRlJa45w7W63OwarSirg3Oa7FUp0WjUYkHdgZ+erH2MuAJWlaRSlpg1iaLy9GL0uJzjCppf1UxWSayUJEsSdE2JQif5U9cSOMkb2Zh8GTVFsvFDFTzT1gIbpgBG/EcGi/OWLxUc4xjFlSfXG/5jXTR7HIia+XZeaTmLykWAnXu57mN87POsamxKF4i/JZsAJSxzH0s1xLBGJ5eO3++qKYifZn7RNG0HddvXnNx/YyL5y/pH+74+NUvGPojx4d7Hu9uufvwjtt3bz8LVv/aI6hIyDGWZFifAGABfvPvqEl8oFkuKNST36SsYm0k9KpOvMA5w1llxSDH8iYrVszjk+ZhQKywUS1+eBq7m8Fq1pPmDbJoaemzGZJkS208P7V8Os9SAZ75ecvt5h/meZp9UFKhPsXbqoVyGGNyK89xdilAoqwdSSSqgBbiCuIGwgY7RNwUcN6nuugO8GjVoNBYO0jhFj+lfWDEuUDfj/gQsT49mYooozC1xKjXlXgcq6oleIuzExFPJIcRBEhFQ9rNhrrpBJxHgAGFZ72aqKqAbw3eKSk+4BQuaR7R9SjTsr+4IMbANJwI1ov1F6SaYhjOJ2ZWhOehKUpMQZpxPtnoqnxPgEZM6+oTDSRN0cwnmufMAqXk8cwUBDGeMV0tJWGE1EeiaOR1PMsVFiwBMgkLywokb1tVAJv3jhjmSlaXL5+xu7piUB3V44nWeDQBP5zw1gqvOR6TumQYHMMoLDsuCENFVRvquk50nZO0sGrRqkarGoKF4FIuhEIRxLCRnkVCQ4yUFs/PFFOlzCBgNctIpWJy8c+gP49lthorJV7YmXN8abmOhKCLnC3em6Qk61QdMrrz2PqzBUke9yjJcCEQnFh0VRqv6NPczjkYxNmYTp5eCyaZLzi+GKz2pxP/73/5R2LwvH/3kfXuimdf3RLQ7FYN23XLdtMxGo0KoLVkUepUztIQ0SEw9j0Wz83tPQ/HgbZ7xESNw2GM4n38M13XoAlUVc0wTPT9ibfff482ms1+K64s6+lPPff3d2iluLq85MWLa15//YKrqws22y2VqQg+cHp4xMXA6vo5QRucdYBis91ih0vqtkMrRdd1aOsSYV6gamqqqi4DE2NMgkliTUWDiUzWgoKmaRJIUTPxsBYtx1Q1lYHJjgthmAVrTH/LBiITKNHKhIB3jqE/Mo0T3sl5RmumaeR0PDKeTvhxIIwjcZpK4HldGZra8OzymourZ+zWW5qmpTUNXbXi5e4Nm3Zif9Gidc1mdUWDIlhLDGBiwEQpiTb0J354O/Bw8xMf3v4Lb3/6R969/UfGwzuG4x1tZagrxbP9G7arDZtVx7prufWBYZh4PAYOj4FT3xNx3LvfY0Pk8HDAB8t2tcXGgZFHBjdw8/CA1lt0tZXsWKMIOoj7TH3GdRBJrhST4n1zpm3+ySXjVLEuxgwYE8jR+bKJqF1HCTZHg46xFIWAtIEma2aMUUrnlUUIVQoHkfUaZwAQKXNkAT/SMVuAYKbROY9hWGwPT/Ht2bXmK0u7ZlaJs+/nmLH0QcEWZ6h30agCRpPwUvN7kgX8qYhLtxcAlTX2T3hTnwJT5vczwD17P1sgFp3O4vynz5l/pQ1WVxXtelWSFqZxYDgeuTweePb6K97/8GdW+0tOj/cMx8cSq2inSeIVObeK/dyhYnLLlw1DXutPGC3mcYhFKdBlnigoltRMn1NpKRwqvxfzJD19SOukxDUvy6ySeQBiOkN+zgIqFgB0tvInyFhOSQCh9Hn+Rj4hh9QsnzGD3AQko5qNNov5lC29OcM5LCqszTAUctx+fl4TZ1ibLala11T1CkJDDB3BatykcV6DtzgLzkkfRaTstVKaaRxTUutJ5HkKTRknj3OB0yjsJD5ltVRGF/J6tBLDg1KphGhIokX6Mc/Vyghjio4KnAflUMqzWZ+oG8flpaOqAsfHinFUxGiERst7jKnY7HbUtZF7BE90FkIohQ4qYxI363K6iRu2ZNMvlMmzef1E2ShQ8SlGXXp/8hpMj1nCBiBROc30T2W8iyzi/LOzdsQ0a5P7PD1TTHG/IUoZjeytUooU++4LuNZGE3NJc6NLforRogz5aSTEQNtUUCn6Q0qq9tKutm0IEVZdi4+aaFZ0q46rZ3uyQ0ObFt2s2W1bLnYdD3e3PN7d4yapVKajlnodIUuvlCKs856gkpVeJXCaeTtYnD8Xt3kKSMNifRdnXMzJnbLec/5EXBQvKPC5rHVSIm3u6yQrFq7+rHCFuGAHibNCI1NpkTSsZs/Z0yH+144vBquHw4n/4//+r9j+yJurDVfXz/nutzdcvXjFN3/zG7bbjv1+Ta8NwYExlQA6pWiMoSKiveN0OuLtwLuPt9wdTmx3DzRR0x97onc83P0LbWNY1QL+xmHk8eGR3/3974iRxH1a0bWtZMX3Pa9evea7737F6zcv+Pa7N6y6Fau2JUxCa/Vwd8/xdGL74hXRVFjriMBuvwfvaFZriJH1ao0xU4o19XKvnIEZKJnh1vsEVitiJPF+Ktq2TXGokWmSBDMRfJIZX9WavgcBqDb9zqvVQZlKATCQ4kyctRy9l0IAk7h4vNFMw8jx8YA7HXGDANZoR1RVU5mKtjK0bcPz5y+5fvGKy80FCiV8fPWKN/tvmaJi7J4RVSVucTsQb34SsBoCJni0d/Sj5e3xwMe3v+f7P/xf3N3+kZubf8JNJ5w9sW40XQMvtWK32bBdrdmsOrzznPqR+8fA/X3g/vYR5yHc3eFj5HAcqKuK3f45ExUf4/fYCYbpnrrRrLdpURqFN5GgLOckQ1kTBUUCq8lCKhU7MuijCEzIGx4F56hIcpFGok+CNlF3ZRFpTBYHGtwMVkKy4iZjq/AgoihFMpIFUSegqnKmd8nunsGiXrSxCP8CYpegJ+/oc2/MUKVI/xmoZiF03nPMtCLp8kugksFyemPWgjMoDIuqMhmMfl5+ZAtqDqnJ1tFiLc2XXQLWwu0oH2YhfM4MUL7NJzdXnxeFEoNVYYyhXa/YXV3hrMUOYylksv/jazaXz/nw/T9z99P3eOeIPtA/HpjCiAtzLfpFCz45dFSl7/PunWucFwG+BAQLHJBZCjLzqjIplMEk3mcllewrlRNjUgxmzBuansdksUGcH+XDxT8W4TFzn6UnSm9mHstU8SjZ+1Wx2qZr5gt9sjkpMuOBgjmcZt41n0BqtXiEmFpSGB2Ta12VNsj2LzJBaY2uW9ruimhX+HErpPxHi3UOZ60w9ATQJsUY1gICxrFnGkeG4SS0VEYoi8ZRXMGnwUmGuRc2l9jUuQw9aIWJVQKpDqUCSscUnpSiv6PwiTZNKzjAepTp0WZit+3ZbB3Prh2mAhXFAkts8E7jbY1pV+z2e7RWOHsiOIe3EwqoNJhKi6ewehptHsQokzPKU1t44nKfFb+iMs3zRp2PZ/53puwsvEMFvOhZaZPz4jw3I8yBtOcK5wzt0vzUungRAsnCp1WZgzIPgiSxkQFYmq9GirXUVU1T11RKoWPEDQNE8QBqVXOjUhGdIB6PuutQWrNZd0Jv1WzYXWz45tuXqfR6w2gjxzHy5vU1337zgj/+87/gnGc4HAhelAgVNE7lRLmkZKXYc1Lcr7VJ3utlzyclXaeS73pO4BWvSkGKqJh8e0olXl+Z5IpYDFreZ/kgVFUl7EwnOZXzP4xeiCuZO8JAkOhJMwVBVhZiDnVJ8iUmbgQ121NVHke+7PjrKliFiLOeh4eBwX3kwf5/XD57z4ebR65fvOLrb+4SAXrD1eWGv/vNb7h7dsXj3S1b5dEqxXpMlnGynKYJf/eR2jl+8dWvaEzFOHygqRVNt6FrW6qqQSnD81cvCSFgqoq6atis1tRNQ7da8/z5FV999Yr9bivZ50oW/fHhQH84cvNwTz8N7N6/xwbZcOxpLBmdo7VooG07tNZMk4VkRZmDnMWMbbSwG7iVY7VObTQmuaI0yqegZBwBj07WNe8dKgefAzOduCn9m4GQ1hWrZkVbtxglLj4d9WxZCEG0tGkiTCN+GvHjCMEJc4KKwmfrJ+IUcKcee+zplVDbHPuevu8Zx5Gga3bbPapuCUoRhx57uMFoRbAj09BzeLynH3s+3n3gpw9/4E8ffsfj4wceHh6YBs80Brb1wLp65PXXA36aeLi/IerI/e17Hu4+cPdwx+3hnmMY8ImUWeuai6tXtM2a/eVr+v6AidZtHMYAACAASURBVD9iVEPXXqPqHbquwSip/hUCTIrpnLkqbecCVA0SW7x0ZOZF8ZkpTa4pLdy280LLoCESQYNxCqstwrMiyDYvOR8lRUNH0D5KHFnMMedzhrsAX1U4/hQzcXOJBVvCw4VldRmvOs+VGZBGzj9ST57z3M8WyrVmcLvcQNR8DbVoUXx69nyjn7MyZmwRSgb6nIm+DMDPIGS2wOYBmq+dEwRmoHt2l/OXS4D0yeAvIbgkjlUVqJXG+IaqaXnx1Vd0qxUXz694vPkWN02p2MmEc467m48M/ZG7Dz8xjSfhS46cNUVAqlg/cwgFiQjfxPl5CnP/4ptASppQc2ngxLhSpZKJOabeFLCagaJcI8zJ0aAgoGXjVjmjWiZ5ZsJQag5KguWGMkOVUOZFfqYZpMhfs6IkENYzo+V5XqlEL5ctsoHZuZstrQJAZ6Xy/Iiz4rZ0Z0fZ3I0xNI3sH6vVFqW2aH3N2CuOR/F6YALBTlg3itvSB7QRD8zYS8LdaTzhvAfTgNHiXo0+hQV4TKXREWyUHIZpEtDq7IBSmkFVyVKVN/7EmYm4c1FIUYLo0UgS8WbXs1pZLvYDq7WnaWScnNXY0eCdBhq2+x1V3Yi3TSsqXaFbw3bdpv4VHu5KGdq6Pu+9GIjBCnDWmW5sBqJlzRSZkdfS2Z9lqj4x6hdu35hFSi6rGTNolItnK71azA9dZN081LKeUyT3skSnQjhNI2IIOFvrsYDcvB8I2b/GOgkvvPnwkWGyeG/pugrd7jE6cnGxEQAWPdZaHg6WqtX4RhNcxRgaKmPYrVtWbU2MCu8i3jl03XB5saJt6lRtMhCceGVL6CCgEzuHKC9PjBBKwilV0MSo03iJVd/75IXVofRnSAmwy+tnC3VWEmLeJDKkQRJbQwrBIjGFyL50PrZaJaUxCuAtv/N6V4u5k0FpGnexbpMA9HzdGGfK4C85vhysRiBEvPU82BP+8cTp7Uf2+z3v33/kq6++xp1O7K8uubp+ztXlhmfPr7m9uubx7p7xw/fYxxti8NgUx3qaLP39RxpnWf3tv2O93vJwv6Yy0HYbulVH9BZT1Vy/eiExGCiaumW/2XP17Iqvv/mWy8s1L1/uCNYna6oiOM/h4ZHbj7fc9o/0dmT7/gPWe8aTZxqnNFCByQr9RNe0VFrjnLh7rLUJVM2LURstYNV61uu1VLoyouMTxaKQN4QYvVSf0uCDK5U4pDMdWaCfH0LW3DUdXd0JWJ3zfgEl9YiDx48jcRwJ04izI5LtKEDVKIXyjhidgNW+55RCEo6nnv50YhwmdKPZ7vZU3ZpgDO5Yc/ypTmB1wg49h8Mdj8cHPr7/np/e/4E/f/wd/XHgeOwZjprxpNmbga2B/jgQpomH+1smP3F3+57H+4/cPtxze7jnpA9E46i0oq03vNz9Hev2it3la1D36LBD65bt6hmxWmGrGq8VTkEIDusUk3/SZzkWLW3mMUr1l7whlm4u8vcc3BTAmoFTqXMswF95cApsDnhVVVrsUgpQR3G5aqAKERXIJb0RKuZsWU3SO49mAqmiTS82XHKYe7LIJU13KWhI1qb8EKVHVNZWl8I+33d+6JkfdglU5+6UF7n/5s7Lm1TBxU/2tEW3pvOlI8SNThJ0C17Vki06j0qIyzGagevs/k9gdX7ks3tmXJifrACkJ+fnxisUVEJTk5lF2tWKZ69e8ez1a/rHR6bxhJ+sCPgQ+PPvf8/9zUfGsccFS3CecxUp3yuRrednUZRKVFEpfEQUXR3POjSSY+8kgUorIxXYkiVVowWkJtC6lCM6EwyAkHcnwC8YIBSQGtW8qSx0lEVv5tCR2bqbbaY5xLRA1TDH3sey7S4UiqwwFUASkyditprmE3XyPgSRppyNnuJMCYnMYFUXRnJFVRk2mw1du+Zy/4IQtjj3HKaJgzvKXNKOECPWTkRnid5jjFT6OTxI2NWEI2rodhtM3RCHiRAsk5XE2aZtiREpFuAllrXMxMSAobVkU8/2XumLyhhMZUTGBE9VjaAd/z9lb/YdO9Jd+f1iBJCZTJKXd6iqb5Ja8tDt5bbc9vJj//+Pttdqy21JrW+o6Q6ccsIQkx8iAgBZVVIJtViXTCaRACLixD7n7LPPdjOwv3Zc7yfaNiKtIAQxg1XvDSTL9mqH0iaDlyQxjcEazdWuLc86ICPIAI15yfMnxcyjVLrIKr1eRdUmrMFkgrV27bzg1hmY6swsEdacdperc7LMpJRe/h1i6S5V50+9hhohlS8mKpXfLSsxfJlK+Z+0OGZVn9S7gXGauP/ywOnco9sNTWvo2garJddbi58cKUamyXFOE9IpnC0SnKFBG8Vum/XYiVm83/vI1rZcX+9orM4BMV8aNZTmP/VRVoWJClZXd4QQpRGOTFDqMLz3uYV7zLnXrI8qssqHAJFiScun0sGq1G/EVRaqRrnLsw9F3aJsMwWs1kgt8zOrVII8b5as2AyM5x2h2I36t5LsxM9dytJqXFZw6FccvxqsSiFohWQUkpCyEVRCoJsNzf4N1x9+x9d/+x/pT8989+1HUsrh4a7p2G8bknoLtzsOV1dcLmduLpHRPPLscmvWKCJCwWa7R8vcMiz6wGa7pW072jYT3Y22dJsNb9+9Z7vZcHt7jZYRg8+pnb6nP3v63vPlywP3D0+IztDurnj74QN379/xw59/YLr0mMJXcS5r5Q1DP7fszIOcQ9faWHI6fswRshBx08ilvxSlA41MRZZelUpxmQntdUHmIimbo5kpFQMjgBYhFKamJZsNm7bhqw93NNaw6WyGqgmmcWCaJmpVqZQSay3B5dRG8p6YHI5Qe2ihpOTxPvdE37p3SKXxLhKixEfAB87HZ6z32O0GEX3ukiISzg0wSPTzE8P5mf5wTz8c6ONAaBxKU7QIA7QbdPOGPggej2fcx+8wz4ofPv9Xng+f8TyhmpHtTpK0xquA1CI3cLANKAPKkmSLUC262eKkYSJHXQIKHw3JW6b4MqVV260KnzvJJJlT7LKALSXFAqpWaecatckRsbr48vdzlKlERmMUhBCKBxxIKqFi5mFLKTAyrwcfEkLFVUvFnM6eF2YFk2sAPSPqsuyrLRav3vzar6l3klHJbHDqKathmL3fGuaIonQgKRv9DChEAaj1GmrRDVRC/xy5EKvvf+GyKsB88VW7UJWWg3NKv/K3Zlu2Aqss47OA1vU7+Ml31Hurz6Aa3zoA9ZG/QLhlnkiZ17KAbrtBaYV3G6L32ckbR8YUOLmRx3HkOOTOeS795ApKVDRHczKHbIkkJxYgOUeKY5qvo8qfzRFU5KpYMM0DnURErMamgrj5GdX2juTGAql2p5lbYeZTyXJhs5bmi0eT31VEhF6MvUhUvSlSLfpZA5H5YhaOdqJEgMUyT2aYXpyrfAVqHqQXmsLlvRJAZT1r20i0lnStRUmD0dcEb3j8GHC+5zLeE4NB2i5HplNEqx4jJY68+QvbII3l+qtrEBIXfFnLpRWwylX1u/11Dhi4iRQTtlGkmDVZ8z1kPqgqsnmZkpT3BqVkBsWlJWZjFUYntjtom8Tt7ch2N9J1DmsjSANB5vPHnHlLSTENI0p6BAHZ2Jzpaxv2+yus1XSbBjcM9IcDtnm11QuJqF1nlFwpCL1eTXm0YnqVtl3ZASqYmW2CIOvIFs51lWR5cfo6zpF5Bq4yTogF2GbVt2W+L3OygE/WGcty3nI9tdVonvO1MYDneDxwOBx4en5CGc3+9o6m64g3G0Jj2LU3RCEw3Y4mWYzeo2zHbneTqWXbll2n+OqrNrdbPx84nS58+fLI268+oK3kx+OF4+HM5XjgcjoiUs6m1vWeU+1ixhxZeq44BiLvW7o88CrlF0io0oCgZutCpDQNqEA05rlCdTLqw4IaDV2KL1fzoT7z1fDW9ZmlBdP82jw3yv5R+c+iRlJL5JXKZS1Cs1Uit+rProMk/9rx65sCAI2QmAJWBaII+LfY3TW7u6959/v/gb/8w9/z6dM/4MczYTrx+9//FW+uv8ZsbpECdLulOffsPz1yCvD05TPBuUyO14K226JFmrkQbduhteLu9galNG2bOTpf/ea3WKPprGbqj4ynBybvCcPA5TRwOAw8Ph14fD5w3b2l22y4ubvj3fv33H//JRdQFeFlN/YE7xmncW59mkqoWwBaL33nU/FEvHMMw0DwASUVKWUdtCQViZy6hzyhEgnbtGw3HUd7KFV+IactsEhhsWaD1obr3Y7tpuXt27cYJVEqzQ5LlQ7JYDWnD4zWTDWNEwPRT8TQQ8zUBiUUh6f73PRAGpRp8T5l8BUTKQSG84kYE6YxEHNfYVLCOQeiZzweGS/PDOdnhvHEmEYwEbUB+kQ4JkTboTY3jFFwuPQMnJDa8+XxjxzOnwgcUMaj9waM5OyzHIhtsiwXSpOEBtGCapG2BXKnkAI58VHjgsbHl8UCSkqsUXNf45Rq+9lSa1zAaiptUsMMWNNaHm5JV1D4paLy5F4C1sy/gihzFEgqgQwKRAGpIXcakzEu566RwBmgvk7t51/ORPn6HvkyavbyeOXFzqdfNobFk01VPWm1qPPvZnBDZf0tgLU+p9cgerns5dpewogCEms7vxphrR1x5la2q5/hhUFcbqIugAKD0vwJL44l+rN+0PU06SVIpdy3YPYicmRBlLRXLoJo2g7bNITgCcHnCHtppHHxE8dp4jBNNELMJZMvrmluCpGvT0k5A+9Uh6BEnvMYiXkM69+qEkmtEZgaWFqmT/nUwgVcHl2mtYhUgJ6QOSggBFVYvW5wtWtbRZIV2IvlRjLYrVHM1We8eMwVchbQK2ZJspfORSKvrzhD1+UNC+4oMjtVZ3XFEl4to1JEJNhtJY3VXF9vEViS23E6wuf7wDANHC4TTbdnu9+jUiIGj5IaJfPYZTCqEU3L9voNttsQRkfwgePzA24aCOXGTbsjxcjl+ZGYItbkrFVUlE0621GtVVmbsagCKIzJQRJZ7sqohNaJm31iu4vs9462G2gbj9EJHyVBQIyyyO1l58cPjiA9SjqsgbY1bDYtV7sd3SYX/VyOBx78iLUvt/q5NXdtkTgPY+VQvzAU85hV5dJ56RejUG1Z7XCV11YZ+2rr5nFdAP289ur5yr8LJWl1HWtPvMz76hC8LNZchN+ElCiZtchjLDJ5KXA+n3h8fCi65uC9Z3d1hdUBkVp82IFQqKbDJIvQO7Tp2GyuUEpi1Jb9RnL31nI8PPP58yeeHu75y5/+TBKRu3d3fPftZ/74xx+xKmJVom001mhqcWmlO9SuUllSLUtsSfKcljKrJsSYCGXySVVtSH6WKaZchFxX7crupxmArmKf1d7MdqiAerG8bz0cGazOq3ZZxOXdM5VD5nmViKsxTisQvLg/c0bmxf73Lx+/Gqxqbdjf3hFVQytkDkMnuL59w/X+mk23QStFu9lydfuBpy/fcXp65NMPPzIdDtxsGzqrkaph12n+7n/7T/yPMfJ0uhASfP27v8HahuH2hhQ8jXRIoUghIpTG2g3dZsPd27d0m47dLktSxWkgDAPuMvJ8/8TnHz5y/3Tm6XBhTKDahrsP73n39Qdu3tzSbTf4GLiMWU9xGEZaYzHKEFxEqUCIPmubmtxJJIZACB43ufy9d0xDjxtHUgxoo1DSYJXCdltMs2EMjvOlJ0+bULy6rJKglcULTZKS3eYGrS22tWit6DaGrtM0VmOMQhudJ5fPsiqma4neE51EK4tWppD1Zb5GN1LJzFJoIorL5EmXAdoeZXKLwNE5Tv0FnxJ9/DNN25JcbnObxh4tJdYaRPQMp2fcNKDQtGrLvrkj6AtBX3h7veON3vLu3d9wc/vX3NzsabuO8/Ej4/Mz33665/l8j0Bibce/u/07dNvwX/70X+inyA+Xz7R24ObWMF5GrDFIpXDB4cl8newYCZrNBmuu2G53LydnisTgMziXogAOicqQtVRZQpI1Oifmxb5wSSnArXDphMg6eyWDUDfpWFIniSzgrETWgPUhgJAZpOo4i4eHVDVbfwpKs3GvL4vlP1l/z4vFPIO+2UxQDHsxAvNmX6FnTZfH+otyLlm83MyfzFm08vr868W41L7jNS5Wwevr4zUWnuFkmmO7L8D/sl/lbyoQTYtVXc60SheupbpegMO1BuBKleAXof6LTXn5jFSeWeYgjkzjyMcff+Dp8YG//PmPPD7c8/13f+Z4PBBTZLu/4u76DR++/io7XuWIPnL61DP5ic1Vi9QKbRWIRBSV95WLMJNYj1UCUYv2ZkY2sxbqC0ehwkZBpXpkaaYi8CQSScaVFr/IvNMCeis+lSzAvaoRzE7LanRfCM2s5l59lMs7qmRNeRb1Ost1RJnnh1rN3RrRnZ2R+T7XlI+ENlkBYbcxGCPoNiprmhKJQfD0KWd7ToeBfoCHx0BMkpA03j8zXXrc2DP25+yAX56IKVOmhDVIZQj9hI8KYw22NWj9lhg807AjplAcm0S4viKlULIpnqk/EYMnTP0CnsjjqqRAKzA60dgBrRxaO6xVGC3Z7Y90Xc+mPdI0IwKB95LRRcZJEsk6nW46471DKYPRlt1+n4t7h4juNG/v3tM0mq5VDJfExZ2Ywv4n8z/buQo0a55JVCGaF4eqtRXFDqY5JV9eK2ApVstR5lWNqr62DdnWVpBcZtnMt6OoiqT5MxcdUOa0tGQFo2s6WpDPUz6kBr2W+Zp/531gHEeG4Zwr9A2cL1u8P9E2LY+fn0hJ8unLhSQM7775QLu9Zn97RwIu5wNHF/nuMe/Fm/013TjSbhuGYeDPf/wLXz4/c3h64vrK0u0sxihskyWuYkizukctOs33W9jbpdaFtDT7EEX1wxhL1fTN731pu2pL5zoG9bmIeR/LzzMl0LK2ZC4kn5Sbs4gi3P8iEsrLz1gAa3Y88366OCAzmK6gtY6PyCuilMW9nhm/ePx6GoBSdNsrpiTnKvgYItvtFZtum7ttCIm1Ld3umqeHz4yT5/D4iD88IW82iG1Lu7/Ddlv+6vd/QG2uGKZASCBNA0kwbfb4aaR//pQ5KBFEEhjT0nZbbt68oWkMbWsIY2S6TEQ34ceJy/HEw+cH7p+P3B9ONFc3mN0VVzc33L1/x/Zqi20sPkXGKVf9OpeF6qUQaD1luQgJSue2q6qkEGLIxWHRO3z5O+9zNZ9SEmEMwlq2+z2b3TUfP34sw1giJgUUydJ/OU8ATdttMcZiGo3SgqbR2XgZiTEa3TSkmPAioI1D2SZHXGJCFaAqCmctxUgILn+mgCQkSShGF2ByyGFCBsnkPJP39OPAFALncaKxLTtrMICaRlSpkAwxFPkWh0RhZcPG7HEq4fSA3W2w9o63H77m+t3v2FqNUYLpIXA8Xnh4PvJ4OrFtr5DC8nb3tzTtlr+fvsOdTzzGZxrrUfqWOIVcrKYkPgaCqBumRglJ2zRc7XJR2/qoKQchsuRMLJw3VeqFFz5Q8fLDwoeq4OlFxEYs9lfKrGgxm79USOw19RKzS1l17WKq/1YN0QoVX/urNQWyggOCxZjItZdbrHRaX+ViiWryB15FHauhqPde/58WKCrK/a+DGAuIW6Kp9euXgOpPjuXh/vR1XlIuFrDKPC6ri30FKtfnePV6PbL1/BWXmV59H5cIe1rA6qW/8PHjj/zw3bf843/9f/j86SOn4zPOTVztr3Ih1t1bbu7eofRiUlNIjIcJFxxd0yGSyrxHEkIGclIvq3/U9N1iM0qhw8qJqYB0HgGxItO/uPkSgSlzprZSrdtCnS/rcZ2jH3Nldp47yyxMLPNxxsVz4fbsB80b2HKOuoozBk/zGFdMJMsJ5+tLy2esXJR8FpHloYyR7HaWtpHsb3InOTc4+ovg/Jy4nCP3947RJU5DKN2FgDAx+mfGoWe8nBmGI0N/ROqIVInGjbmifpqQSdE2FmM1trEgEq6zJRpXbE7sgIRUghgmhrMhuInxkm2Cd744PgklE1oljJ5ojKNpBqwdcnbJaDabC01zpjEXjHKEZIkRpikxTlndOAHejzgXaaNDCE276TDKknxEJcn+6hptQGuHEIkx9PjofmENZAATapbltaRU+X7NYVxGdRWhL92i6nquAKZKJNU5tDYHc8RPMEuvpRKRXY/6TG9Z8frXdqnO17WtXMvepViaANRCxwIQnfcM/YVpGtAHxeR6lIg0tiH4Z2KU9E5gmi1KW2zbsdld4WPkeOkZvOf+NGGlZNd1NF2LbTOt8MvHLzw9n7mcTmzbHVIYlJZoo/M9zxtInej1HhbwliJZoaYOiZAImWkAOctb7PFLEz/vZyktbp4qADXvbYtsmlivX6rdW7jVFawquf4AZnC83kdgoRfU15fAQloW9osL/hkZyl84fjVYTQk8MmuLhXKBUmKMZbvdo3XD6DyTd/gwIogYKbFa0hhJmEZOfuSH735kcgHe/ANys+Xuw2/YbHe8//o3NN2Gzdv3SCEJ/mtSCIRpwmrDm9tr2s7SNQqBZzr2hHFiOp05PT3z8PkLnz7f8+OXL5ymwBhg07Rsr/bsr6+5vrnJRUGngYf7J56enjkeT4xDz/7qqmgXFlsdIITI5XwmxIC0FqTEWANaYa3hdL4w9gPjMDAOI1e7HVdv37K/vWO7v+G7b7+nsfelW5Xn6eHA6XhiHLKGaWv3KNXkkL6ougCSRhuMUnjvc4rDGKSUdNsObTTaGLybcMOA6jrOPjAJA812liKpYrw+RUiCi/e4YSCcnlH6wpQSow98OZ7op5FpcmyahuvO0mnFJkz4FBjGS5ZpCZ4kJJtmi9Jf03VbLv6Rs7una+5o9Rtu3v6Wq7t3bLXAysinHxr6qNHxhi4J3nbv2W6uuDx5LuLA03cXng8n/HCkaTYE19KahuurXQb0OuGFx5IIUhJU5KozvH9zzW7TvZibWQcvoI3BSIl0kRglsmjYVvCZ4pKyiEnMXTriqwWIyClXrVSOhlQR9tnwphU8/Ok6yfQiUdQFKhCVJX1Xv8QMEPJGUASd5fpnVil6fubTFksz47bZk62GKq2kWyqIyBHVrGzALBSwtEKtp3+FQGBl8MQSBXl1//n5pvm6Mld1+d0KZ78A14sDUQ3wy3PMHzaL6f9rR77+XGAhFoP6AvTXI1N8Tqcjz09PHA/PnA5PfPn8mceHR77//i88PHzh+PzMOA6ZE9hZmnaD0obHp2esMbk4s55dCjYbSz8GpuMFh2B4VEijMdsmFwQqTU6Gu5KKj0gZETIu82OeQ8szCwiIOXPwoviu3Mv8BMSKfjJf2DJza9GPKAWJr0d8idrUApmXTy7OifyS1BY1Qh7nTxAzSK2yfCxAoqT2FXWtiLmTa70IVTrTNVajlWTbNVnP1EdGn/jhMBB84nQM9L3g80eJ9xoXDCBorSHGQBhPuKFnOD8XxZCAtomtbUklAuemE+c4MY3PKG3oL5tVEROYbluKhXIL3TD2FI01gnf0l6dsn8dTpmWlgBAJqSJNA7IDhAM1gQqgfGkgIzmfHZc+8vCQ16WPmpgU/SCYJvjhR8flEjifcjOZsMvRtcvhwHazZf/1LZt9QxQTp8uZp6cfOZ6e8cGvujzNA5sfcIxzKhxZQakgyQpaymAUbfFsltIMEmvveKlyI5sYKhmmNg7J0lgZj1V3tzoeiwJKovIuK5d5ieqnEox53XGrFqhKrcoaz/S4au9qRK/MwnL+rGfYdR37qz1KRZxraNvcPezwfIR0gmRAaHR7hZUJ3SpspzGtRoaIbSwpKaLQDO7M5fmCc5I3b98x9o7zaeLw+Jnv//gnpH+Ple9ojEJ1Xdbf1YsIuCzgWhs1Rzwr8IuF0wpk2bNavD3fXwHtdT3NzmDK41X46sg8plJU+uhr4FjtdILC710cgZlKX5yRSpGshjytbEotiiz83PXe8eoT1/vBrzl+PVglF6KEshmLMrGU0jRNh1QGHyI+FIFkMj9LqywWH/zEGBz3P/7A4XDC398juk2uZH3zFt7dYUTD9b5D2walLNEHzk8HjFbsr6/mdEnyHj8O+HHCjRNDP3A+XTidLhwvPWNSeCTSZGmrbrOhbVv6y8gwjJxPZy6XTAFw45TNZS3CERVw5KiK1CVRJYqURFKIpJFK4X3A+1AkTDSb3Y7t/or9zTVtt0HrJhPzPVwuPYhQtPI0XWsxpllSMNnSY1ROcdVIXYoRlEIX0CqlxE1TBtfGMPiAR+TiJN1ADCRfOqSErEk6+kCQDjFeUN7gpWIMgdMwcB4GLpcTY9MwXI4oY2iKPqnzEzHlTlnKWBrdYIyhE1cc+w4VDNv2DV13y/Xuhu32ik5FDJGkDFOSSDY0IrJr7tg2O1wfmIKnf3ZcnkdOp4Gmmbi+PsB2x7u3+8zrEwlfSqu8DAwi0hjN1XaTBZtXR0yJkCJWZA4vMay267i0qyMbzLzXFO7eKiS0fJ/HW5ZNUhYj/rJisx6r19KyANN6EVZR+Jm/uGIRrdIyc7prHUkTiyF6DRyp53gNZ9NijNJ8LYtUDhUMiuX3C3iswPa1aVl9woqi8EIndXXq5d80OwJzRWp6dT7WW9gScV1HUF8A2NWjfzkiPzc+9UZZ3+RPP71QSS7nM/f3X3j4/JH7Tx/58Ycf+PLpM1/uP3I8Ps/Ppmt2tI1FagtScbn0nM7nVXe6HCW3jcYHhbuMuYjWSXRjEbLJskdWA77QAFbpyrKJyQJYX2iKzhJ2aaFMvAhxrMfk1f9fbC75e1F/FlXVdPVsXoS5f/p8xWrc8gvpZ/9G1A34xfa1RHvz1rgkdhcd4bzRCCGwSmO1pjMtSkrGsc9SikfHNEWenmAc4OGhNGKxKbfotpIQXe46NZ4Yzk+ZrmkEWhuUsYRJEH0k+jFHIn2Pkgo/dgip8NNEAnY371HGAlmL2/eXDHRTzmpdzkdCmJjGcxlPj1SgTUKpMq2FB+my3Rcp94wPAuezfvfYS7wHHxUxSYZBMDl4w6BVAgAAIABJREFUuo+MY8JNEqmWPu9uGInW0m0sttFEHMN04f7xU67DSOGnYLWMbaredeU7l/lWR67al1jHsyzDmXxS07uZWJn/sho/kV7QO34OlcxgeDZ3YnaaZ3NVHeMKpNdTsaTHSRnIRbHMyfVErvcis/Ao1hratiWmDm0E2hiQkv7cE3wAYZBSs202IBJKS5SRaJM3R200sXRM9EHQnyeUEOx2e1I8czwODP2Zw+MnzteWsd9mqpqg8EthltSQuYhQqRz5jXNBZAWQYQG1ElJY1scyRi/vN1WbWzQUa54kyVVw5udW4iojVtd/tTGiBiCqbJVY1jUv/n625K8uaxnb5UJ/MiV+8fjVYDXEyGkY6acJ0zRZ8mPy+BhQRuf2cqXN6uQHjFZcX12xVYFGBoKLTNPEl+OFL08n+sGTzAknWjbdj/zf/9f/idGK3/7+d1zf3PIf/qf/lav9nvfffKBpGnZX2zwwMRCSIKoM0obg8XqL2N9x81vLH3ZvOF5Gzv3IV7/7He+++kDbtoRx4tP3P/D48MT3333H548fORwPGdBNA0KkXPQ0p3CLGc/iZVmvTjclfRBQ3RVvvvktyXYMAbrdFW3Xsttt2F9v6bYNptW4oMBnziopoGlQwtI1Ldo0jDEQfKARuUK0NQajFdFHpjgR6uYnnokha755lzmz4dwgLi1h6oljz2U4MoxnsixWzHQDqVAE8A0X75HaILbXuJg49GeOlzPn4wPOWg7PN9A2bNvM6+2lBKnBtNkpabscvWwaNv2WTXuFtlu03XC93XO1aQlxxAfPpAVTo7n7+htU8Hx49x5rGy5nxzCOvH/zjs52fOt/RCuD8CCjxLYtxgiUmggpor2n9yPDeKKRb7nZX9E27Yu56Z1nGEa2mw1t27BpDJAY+jM+OGr3vZyeB4TPxVIpEsViFKIoXFUt0SpXFispijSZmFOeQHZuJFl6pnRCkUqhlMqRYSmRSqJEbreopMqcI1WbHNT3KV4QzWcDVg30vMxX2/hiSOIa2M2bT/ZoYzUahbMVY00Py/ncNdYBxRiJ+YEshqviiHpU736lg/ki6z9H417bonKP69fr560UPl8ArEoX+JmzrcHTwmmrDsCCmUR5hq/Pk1LATROXy5nj8cj9l898+5c/89/+8R84H584H58YxwE3TaQ40bV6PmGMjnGMCBepsmmJuAKBILVme/cWvRuJbiL6gOurosgFP0H/nJVBnHcl+Q/bq5bNrmF/s+dqt8mvppS1XGNk8i7zpmu0MpZUqizlLzUSW+40pgyCfHHqfMp0lVC59KR5iBPMm5NcbWjzvaWX4xjm8czvizWSW6r45zkilzmRI7hFwmx1rnrRqhaoRkNKiuEpEFzimdKpKuSo5TCcCSHkQlEkQhhSymAit6GNEBzjccytTv2ANnB9d00IEe8LyHRTLv615ELUlIh+IMTE0J/I/MAMDic3lLVbnoovVdKpRFr9UK4pEGPAB4cxCmksyAZlW2KKDEOg7x3gCB5CSIyjzoW7o8P7mPvNC4n3ghgF45S7QhqTC7VaHekaePfuit3Vju7KEhj545/+P6Zp4Hy5EFKgiIS9WDlrneMqgTSPo6jyRMx0pNlRn83SImAvtUZrQ4ye6GNxuvVPeKZJimV+FhWAzNEv0T4BFG7v3D4UmBP8c9FydpK999T+8/VaBMydCOeio+L8LQUCWYfXGM3WbInJ4lyWlxIiInL4p9j7EilUIJRAW4ERind3e4bLmYdPXwjDgeAuNNuO23dfI/Uj0+i4vr3hzdv33Lz9iv3brzHddjZ1C81XoMr9LR0XCyAvdlsst5FVGUQeF1Weryz3OUdUCzqf1z8ZsMaUEKVQqioSSFWkE+vaLM8whZXTUecKqURqI8lnAB1rwCeVTxIroFrtb13a5X7rrjH/2a88/k2RVRcCPkasyJdTicF58eYwfSKnJmTp2mTEiCbiU8odPybHcZjokyC6yJf7R6w58fzwESkSw/nAu3fv+cNv/orOGjZdU7ggNnMyh0zhjknik8BFQZQG0WzorjU0G+ThjDxd2N/csr+9QWtNDIHz8cjzwyOn44Hz5czkJkQMEEP+d3mMrIV062JQShPJXEplGzZX11z6Edt2WYDa6EzIbwzaaJRW88ZZBzNXJ2Y+rNaKYXQ5spVyIk2rDJCqHlsIsRhLTyhgNXiHG0caHBcxkaYLcewz/2o8I0q7Pm06pLaEqckTHYGIAbPdkwRMzjFOI8N4QSefxc0lJGtzx9lpRBrQRhTOV+600nXbck8CYVrQDY2xtFpx8bmHcZC5y9Z2t6UFNrstWmtO54mYEvvdNUpqPn95RAiFSkU7UmuUBmMFIoBKARkcyU8okSXAtH45bUOMhTYBRiuMMkgBwY+kFDLfphgBkRIh5TSelAJilrhKZTUJWSswi8yMlEV+RrzAa0Jm45dlaJZuInPFdk3niyxfNHdymVP9cvmCBawi5kU9f9YMKV9GJ17DwaWYI82b0WyY5veKF3TOV37uy8z/OoIxv16+WRdAsIDV2SN/de6fO/51O7W+9l8+1pJN5ZV/4Xx1o84d4Yah53h45uHhge+//45v//In/vTP/8Q4nBj78+wzKC3RegW2U84iiZA3UWWbF0AVsuG33SZ3HAhZvF3K7FyNQ0/0Edd7vM/FmyHlhHyjDTRgsGzMjlScT0XmyUefgFCAYZrnEGTKwCzT9WJw1+nBWoRRv5anVrmoNUA6R/WrT/FiDooXn1GBbn5p0V2df/vCOUrzy3P7AVFjyAqBJiULUeOGETdEBicJAfphIgTP0A+kGBBaIxVsNmUNKl0aKORxdmNPTJ4YHUpnh9hNnhQdIbksWaXypr9Iq2UxdxfcLEFXr15KWbrZsXIWS0FZzG1V5+eRyEBaGoRsEHKbKQkhEvyE9xPORZyL9JfINAqGKXccsiZndkrhNkJqhJBYIzFaZ4qdzVqfm41FGYnzE0/PD7MDlJ/0EpV/tRpm0LIs2gpQ1mO2OIAzcKpZIFWdcMnao63WMrFkB15Oskp3EvMaW2ZOfV0UcLOcdTWd87hVwCTlAsnna55/oNKAqo2TIkuISW2zgs/FkZKn0qQEodxDeQYqq75oVfaEzoAXJH8huT7PLbWh2+6YhpG2a9lst+z2e7ZXe7rdHm3MvJZALEoc88+vVo5Y33XJrYn1LYkCqkVRtVnHSsubRSprMo9pLHysii+0WAVhBItTUp/1yu5XWkWq60EUdSLWSiKrDNr6Unh1pGWL+bXHrwaruQfxDVI1bDtLSBETPN0m6xCmGPHnM7EfYPQ0UmA3BukmhAtMk+c8OC4xMUjJ3YdvsNsdzw+PPB0PnM59bgu3fcf29jd8+P3vub3dE6ee0V0YHlyuiB8mhnHk+flYWp8mZNOwvd1z2zTYpuF06jmfB65vb9jtdyTv6XvH6XjkeHhEIuhsi7m+RonE1XaHtRYvJOM0cbh/wMfEOI0g4PgUsZstV+8/kJLEhERrzlwnyTiO7B6faZsOo3OXEOd9FgMONbVXpDSEwpoGqxsSWTrKl4YEu21L1zTIInUyuik/90IJcJMjxEw7iD5vcNMUGXpPGC/E8cLkspdeV23AI33KslHa0N68xZiGbbejQWBEBoNCgTACbS3GNmht8jWMIxqJ7eRM6ciyVhEtFY1tsd0O025QIjFcDjyNPSc34L1Hi4TjmZBGwuMDVjf84Tf/gba9QpqG0/GE9ArvHG/fvsW2TY72xBzJ6IeBx6dHvO+IXqIRbHc7rH0pXRV8xJU2tFpL3r95Q9davv0ucL4IUuloVTdqIfNmEOuipVAJCthUKkdWjTZZw1XLkpJdLbliYbUpmolaI6TGFCekfimdC8ZE6UKUm0yopU0erPifooYtFkP7AhzM3tOLr5di+VV6bQ1YWf5ezAXZi3Gv7ykpnyp1JMpmIIWcLagQJYoUAbEUfaxOQQWFCzhcG6VM8ZgLcGaDLPNaKYAv/72AGYitDrEMwbyJ1v/Pkdr1UcBDSkzTxP39I4enR/70z//E6Xjg/vNHTucjj48P9Jczl8sRkWKR+1miBDGAKi1PQ9EdVDpHVecClFdH7jwlgQw05FYSY0Bv2iwS7gJuckz9yDQODH3PNB14fjiQphOnh45tk7vZWdPRSEt0oFNie7tBW136vicuw4APueEJ5JahMUWii6X4Mha5unw/Ytb/Lc+8PDsB/KKTUIEGlTKw7kGVf/9yxi7/rQZ2BhRSCCQGSYMQG4RoSaHFBcs0JpxL9EOPdz5rKEdQRiF1RJkOQcK0BqM1++t96fWetS9PD89MwTO5iZRCrvhHZedDSXb7lhg1KeiSsfKMk8fN0oIRqXROAau8Zo3KWphZPSBLGOZGMB6EQBmNVZamtUglMUZhrKXrtlnysDQOmIYh8+YxJSCRlSGEiHRtvsau1WgtZ9CmRA5yvP3wlqZtub19izYW0zUgBI+HB0L0jH7MEVMqgPmp05flvtRckf7CnqxCYULKud3nbH8oXoyUaGtzV8mmJbgR9wJNMYNNUfUgRC6giutim3XLZyq1KEEVp6+pMfJ1hpDthJobDazsmEgl6pjX5ctgUcrUveBAekwLzfYaZS2DzW11+8MjMQaMlWgD3ZVhd93w9s2Om9std1eJGEaezg+k8YkwfiL5Cyod0aLBqsTdm2uudxtubu94+/XvePNmz83tnvF8YBouEKviTCo6sGK+75nfT5q7gIUSDY1FkkuWKPHCGSWvb+9JBWfUoEgUAVWlsRK42ga+GGWl5Qvndnn29bEVe5/c8uzLHpODMqv3rbnwaT2OcSmkLHMh52SWAq9fc/x6nVUhsLYh+IgxGpkSUZb0Z+kjG1zuAiISuUORVKRQLi1GfEjETHSl3WQv5P7LF/pxxANaadrNnu7qmu3+im6zgZC9aHc5EZxn7B39MHB4eiIKQZSSRoGWG7RRdJuWhEQpw2bTYY1hcJ5pcgx9z9BfshGSktZatCSDCpUNkpCSEAMEWTQzfeauNg3CWETKhVjSOLQ1BdDoOfqWPb7EMuZ5sPIg5c9QSq8mQgIhsMZgrc7efcqNB+reW68jxDjrvcaYCD7gfU5jeTcV/mw+p5BkgyUgOUdM0AiBUAprLErkHuNqjiJKlDYopZFKUsnyKazSNfOkzsUfSmqMNjRNQ0iRaRwYp5F+cggyxyymCR8uXMZE8A27bcfN/pb2+g2n44m761vGYWDTtiirM4gU+f5GHzn3EwKDIqc5tdGoV22u60a8aNoaNl1HYy3TNBJieRapxibzgqrGTsoF9OVsUuWryjmyKqVArRdWBasqzx1RAOj6/bVYSpYIAjUawcqjXv28jn787BpOS0wqlZ/nDab+fpWymedXPePPn3T+3OwhU7oepcWpnsOt+TPE7Gm/9I7TT877Eqj+FP4UZIyYKQgzSF0Z4l98HkKsjF19tuWaVug5zIockXEYeH565P7zJ/7y5z9yPDzz5eMP9EPP+XyYN7VMA1GzwsNsyMXyOQvwWlJwr+6OpVgub6JCC0SSGJ3VO6INCC0L8PcoL0jJ45ynv0ByE3KTEDahW4vUmtx9IGGlpTEWYzLtJQRQwhOmbG+0VBmsykiiFPoUSayIKHvLr90tKmARLGS1Oi9ezttfHO8VMK7jJZJEoBHCIFKDSBuCbwnBMk0eN0Vc8IQo8jiIwu0DhLAIAW1nMMaw21Ww2jD2A2eesm2o1fvzuGXHUxuVuwGKXNA6a3GGBVyrUgRnTN7ndJZYyB2ryE0e5h7qhctojGGz3WCMoukajLa0zYZhGDmdLkWvOcP7VFLbOXOnSFGjTXaYN5tMCVMqPystcoHt3V2uidhf3yCUIghy1nK4ZPpB1Zuuj/0VAKmftzhYazuy2Cogz1kpmTuszfYir0+pFVLnLGIK6wKh9cxhrgeo82NZqbXodWWfXq8jsfyufvYCdFbrkWU9Spn3uvozc0Qx0+gSASFjprXZhmCyLGW2Qfl5CQHKCLSVtK2haRRGBkKYiO5E8GeIPaQJKWNZWwnbWPR2Q5IaYTuudi27bcOjHxiHc76k+VLTrE0b5tsuziRFGSEudj377/UpphnrV/13IZeMXXZyYilYFAXrp4JPqgNfP7E82Rdtn5doKqVoO/Oz836apPzlxb5MvvJtGfWKiWok9t9w/Bsiq5LtvgXhScGXiSrR1tC0LVKCG84Ykbi92tAmSYtgCGNOt+uGZCI37z6grh1KKaZhwLkJIQX/6T/+He/eveM//+f/g3fv3nF9vcEoSbx4/NBzenikv/Tcf35kGEeO5yMugQMyeVAyTRPjNNFudrTdhvcfvub2zR3OOZxz/PM//RPff/cX3JTD2LsmR9DGy5lJwMPTgdF5YohYk8G5MTpX7ynFpCxumjgdDlyORw5f7jkenhmHM3YwuL4h3cTsaVqFbRR9n0n2JbFRKt1lSR8JjM1Gbbfb0JZITo5c5agWUhBjwk8eX1I7lA5Ww+R59oE49cRxYHKOyQe0DrmiuBik6+2WZrfjm29+w9X+lqurG3yEP7z/LVftFd9+DxvTcH31lquupbEa5yfC6BAxNwdQLkccUopE77JXrRS20bSd5ePnzzw+P+KsJWrNX739LeLua/7p+2eeT0emdIY0IpkwKnFzd0Oz3fL1X/+B0/HIMPQ47+kPzwit0LuO82i5v2y53d/xzVd/zf7mDSvByHluTj7Sj47Hx0eiH7hqG2KoDSU05/MBH9zcN1mgUEIQgs7C/eRFnAFxFvI2Ss7Vx9bIrLe6DuhKCYVnrOTSDUYXbVxVQKyqHYikmNNhSyxwqQhdUkJ18yprfTYWy4Yyt7sr/9b7SmVTXpylFb2hPDORKJxTKNttcWzqyyU6QY6oxrn6t0YD1te1AP9fBqT1KBtO3fTmblklfFCLJMq5Yw2mvIDwy5FWz6g+Tcpz8C6ndoe+z+niocc5x/HwxPPTE//17/9fTqcDXz59ZBwHLpcjpIhRAm0s1jTzOpycy7z20nlKSTnTe2JKJdMRUAqmqZ8j9fWqRJSQ1JyKW2BDiUoKiTA58d1ahd41M2CWAoIQnEgMsefh/kSaIsfHA8EH/ib9Dfuba+6uv8GYhptuS0yRa5FbfiorSEoSG5upQ/2Bceo5Xp4ZneMy9PgYGJMocyEsDoiQZRMs83EJgZc5OyukzgBkzVOrShsiqcWxiRCDmsc/JgupwceGGBqCN4QgcKEnhPOqb7hAaU1bUvVtZ1BK0liDUoqua0vnKpO7jD0dGZ6e+PiXfySkACrSdh3769vZofRuyh0BR8c0DYVelbv3Na3BmC7XEDQNWsssNZQi05CzRtNwIaaI0oqm0WyvrjDWFsBs6DbbQheQZa0G3OhJ4ZL3FtPi3ISfctBDa4l9v0UbSddl+cKrXQ62KJXlCaVqcw2CbbO2s/dE75hiDmCEVCJm1RGm0kR+BhiUMUhFM3qec1ojyPZMSIltWoSQTLEnhQhCzUFOpTSmaUqAQyF1porlivwcSZslT4UorxeW8tyYbHaJV4A1268YqiOQ72fG3AVhaZP1xRHZqQzeFdAvCt2ugG4BqSifDMMjz09PXNwTU+gJCZRuOD48Mva5uEoqjfeRJBxp6sH1hBAZBse3335kGs48/PgnQnA0raHtOoT8CqsVl+cTV/sdVze50Pqv/tYS3Eh0I8PzA0cfK8bMzwORM5vUmoTlkIXIG1W2+zIWrq7LwNR5v6ytlJsdyFRkwFIkBoqma6gWctX2Nc8VLyVJLcK6os6Deann/SaM/awyVLufCchAOCUKKbb8bWJO26wtdHHqqiMgRM5G/trw6q+PrEqBbQzjkAXbE+QJoXK0SwhB8Jnz0RiFjRIdc/o0p3VT5ngpjbayaBn60nbO8v7tW77+6gMf3t1x++Y6S5OQSD6UiOrAcOm5nM+M08TQ93hgTNnjjilyPJ44HI5cFZ6IVRoZU+bahsDx+Znj4YigpGGbJmvMBT9HXaYQkCJHQHUpmMkjlzeWkBJ+GnMkM/gi+5HTQN657KmTI5s5C7FoJs7RyZmHkzL3yOSezsYoSFn648XwpbToeIZQQEvMGw0TaXIk75l8wLkAKaBk9vSlyhFT2zZsug3bzYbGWFSE6/0NEcXz4xOttXRt1qGVCkQBcbGkumrXrZASqIgWJoM0skl0bmK49DmVKCRXux1WK777YjlJSVAgZOaQEUMxKpJ2s8lRpKEnpIgLI0JYUhS4qJiiBdXRbXcoW0j8SVF7VFMWagiRcRy5KDhf+tzQQUqMtagxF7+IQjJXskZNSlee2kigzPPXUVVVDN8MVhPZCpf5X9P71FS/WEVUF3v54mv+//zimr9UfrFa7GugU4EocwS1pv0XYf3Fo10uWax/qs6tqL+rqfsauSjedhKrzyvztjrIq3P/3L//AnJlATmprIcik1M2rBnEzuB+/SzKVdb0dVyiJjFmQBG853I5453n0l+YppHHhy88PT7y+dMP9JcL59MR7x1umlBKFL6zxtqspRlDQMiAiJmXlcqmX4s/8ubrCSWtt8j2rB+OKPvwKupLfc7lXyERSiKlQaslNlnH1cdSsONGwuA592eC8wx9T9s2+M4jMGAUIklkUggiKgEoUA1JKKyf0EAIU24YEmEKHsJUirDk/JlzkalMS3T89eYzzxSWSNw8CcrmVOaOSKnIuUGKAgKImCOJIWhCVHgv8D7hY5ZzqilqpTVSSKzNvOGus2itaZvctKVrW5QUWAMuesLY48cL43ABmbIN0Arb2NkGB+eIIWewgo/UjIHU2bG0NtN52lahSzvSFBNhikQZECK31zZaYaym27ZYa9luO3Sxt7JEt2L0BOeRskS2lSz3FFFErDUYq9hsG5pW54iqUeyvNrkxi1CIMo4IiUu5+cjkRnzJulWpuNfzbzEjP7MYE3M6OAcB0vxHdY5LqVZtPMtqrDZN5miwrGC6Zh1EdXCZge2LTxe/kP4VM2yd13eKIHPbLta3kT9fluijLPOrpM7nObl81Q5a3nuG4cLoB1wYSMkgZc6eeu/KuSUp+gzkgyMFXzBMYLj0TMOJ8/EJIaBpmxxZNlskKafiS3fJprW0V1cMJxjjlG1saR4jqGn/xY79zOMoz2S5nxrVjCVYMdt7Vl0HRR1ciqP06vxCzJ+beb9Qizhz4Vv+sJw9Xd5Xo6uz4tjPHQmSqMo6P//7OshVeuzXHr++g5VRvHm7JwnP5+9PSKXYtpbtpuFqvyF5gZs8IgUaFZBuJE4n+uMTx6cnvv3+Iz88PHOIiQm42uSuG//9X/01+6sd//O//++4u7tlv22wMuKPj6SQGA4D/enEjx+/4JzHSwHW0ugbrJBstAKlQGn48SPni+P8fOL05ZHTDx9pm9xf3if4/OkzQ9+XFnsKdi1CSiafiy0ufU9CcPfuHdvtls0mT0SnJNJmmankPdP5hBaC2/fv0TIhQs8UAsenB+yuQ7cW58bS3SMADinMukEHITqUhLu7GzZtw9VVixKC4ZJT9to21E4RmUKRPf/g3LyhjFPPYTphU8Di8ZPP/DQDSQvM1mA7yzdff8Pdu3dcNQ0mJqRRWN3w7/+X/53Reb7+8FsU8JtvPqAIxNMjeE9IgnEcee4/c+WmUqmfwXVjG7ZdRz/0PB0PDOdLltcpTvz1bsPVpuXd/RtUvGD8G4zQTKeBL9NnDl7ifGTqh9xowQ1EHK25gAkkcYWyLc11S3N9i913uOT59PlH7tQebm7muRmLM/T4NHA8Tvj4PbvdE3/43VdcbTq6piUazeRdiXw5RIhonRClEraK968jq0YbtBaZNyYzuC3xyTk9NuuiSjk7b1IKtMwSZHI2/MyF/gWfLH9bFm3GrK+gWQWhJdqeYuW3ZX3EWH+Xsmf7c/vSS5DM6vyFS51KFXkFjSl7zCLFTE2LBZQkiEvZLvOutfrI+EtmrAZNZkBeoGrh11Yua67oTbO9XcO7GZSXv3FuJJTCyWkaeLj/wjhcePjyBTdNuDGPtw8R5yaeD4+MQ8/5+MQ05fVUnU2jTQEaFmsbnJtwKaB0jtx4Uqk6rzSfvLnHmDMxPlGqy18+41hVE2IiEUkizFHG/EpuDlDBRobo5Zmm0m8+yQwmtgrRJrquIcXIIXn64xP3l7F0uMr3gl+i4Eoq2q7Fmpb95hptO97fviEKCBJiGIluYKxf08jkxqyXHbMDHArXskbwF/CdWxfn/ac4riIPoy5yfHHKgCNXXGZf3LvIOAa8C1mPVPYkoZHaolQWyNda09hS9d42aK3ZbNq8NgtdShZQJEXJNk0j0+nEl+//G/0w0u27zNHf34IQTIPH+ylHwL3PnYsEbFqLth3ayJzWF6mkdSNGTUiZ5kYRUuSI8P52g5SKbpsLR5u2QwiFFBpEIrrz3IFLSLAWdluFZIO1Fts2iBSQKdBuOprSfEDrrBSSo5oWKRXjlLnG/eTnOo1q86on8WJ9z/5DpTb9PDgUL96bv1FKI5QuHPwqszev3HnJa535+m2bOw4iFESNVJpEQNTCutXnimr3qve+pqCIDBJruK6u82qbZ+4qzHqwUueiruxQL3Y0d3xSK9C2OFyX85Gnh3uO58esnCPvEdLw/pvfsb15C59+ZBrOeNdDcozDhf5yZph6kkj0T98xXQ6cHr9FKY1KtwgT8ekKayymvWIK8HT/zM4HpILD/Q883//I4fEj/eUZ22zRpsmUk7jUUeQIushZjBmYVgrAPNTzQ63hCFmDUqpQMqXC+9K0CFatWAWmadA2MfY5uOhD5oKrqvQR/eK4CYGwJhurXIFY5tJCbZv3LKkyTSDG+dqqnU+1mDPl/E1luRcVsV8Gvq+OXx9ZRSB1Ie3OTy7OXJuYJEmk8rByf9jkPX6aGIaBU99zuFwYpCLKIhvRdrx784ab6z3XV1t2XZtvJHjckAsBpmFkHB1TkcnKnFeQsjw8rXI1qLFoYxFSEWOpuE0febvFAAAgAElEQVQ90Y1MKeFSwk1uqfZcSCNUAd1Y0qNGq7l7lZi9y8rjDLhxwBhL1zWEzuI2lsN54DLkKv1x6EuUpXqrZfDnWFKaF2/XWLq2yWR3akRjiTblkH2Yv1IMs6fjfcA5jxQBU7lTKc1erjEGay1t09BYCzHkCtQYUAKubm7pIvSHHplCrvIPE0PZiCICH2OWK3MTU/DZiJrZvhC8x40jUgjatmUQWcTY+YnJ5/S51YaN0Gh0keQaGZ+ecCHhpym3jRMRRUCaQFIRX8jnUpvMKYuecRq4XCTOvZSuqnxBFyIhJE6XnkiiH6bcvpWsZmBNjsJnOTCBkh4QhDK262c3a6yKRRlgXsDwEqi+iCjw4rXF1K885PW6qjSA+kCXwNocRc3/rnhL9XtWr9VZNYMlsf7hF48cXa2x1VVkI6UCPEoqMTJHFhfXuL75dQLr1T2++iFvLKk4NvW3Jba65seW+6lRY+cdIQS8d5lLPg5453h+emQYBu6/fGToLzzefy6tkSnC2gnnHafjATeNeD/ltsmVFlKjRFqXJh0Zca2T9q+RwBwRKXYwN4BYRadWN7Bwh+uYVauQqBGN2Sb8jEtRhaWEEiATCgsp4UlE73Hukt8eckMCkenuyJRQUhGCw1uHVS0GgWzbnBWQEi0NwiSUEOiiyqGSRAmNjx5FwIvAmCZ8CMyqZyoXjPk5upNvqmQCMxgPEGQG+c5nLmh0keAEfhJ4l3D/P2dv1iRZklzpfbbdxT2WjNxqaUgDIJqAkCCFfKBA5mU4D/zxJIVCzsNQgMEADTQa1bVkRkaEh7vfzTY+qNm9HllV0wV6S3ZEebjfzczUjh5VPRqS3JeJGJUwJtM4hXOarjU0ztB1Fussu/LT2AKicizMUSDnSPQzcZmYp4EQRPvaOIc1rqz7pdhQKWQSNl3TWINtREMzpwA5lrGMciMpF3kgaJqi4eo6jJUaCWMklxTU2jAnpVjsxFZ57pym7xuapqHtWowSQNz1AlaNlYhOjU7VAqFUnIIQEyElfM3PX6fmxZyrOPCCgfzxIvxsQartBxe59pt9K/UY20dXp71qUMu5LmnPnznlxTrack0RD+czYLuS9JU5rKGg8oG1c+N2yovrle+wHkOIHylMnlnmhXla0Ba0VdimpdvtsdYQlJI6BpVIyRPjgl9GNIl5POCnEymOaNXIJC/7Mkph2w6lgmjtLgvj+cx4PjKejszzRIgBl186DyI3yFrxutr9MsZbk4OLIVPq4rnXQs5KotS/lb1Fa9bCyJKGpbUm6cIgr2xqhlhbtRepsXUiVRIhv3Rg8nY9+fNxv3CiNgv3///1i8FqiIHHpwPPxxNzyuAX5mHk5s0ZHzRds+PV/op4UiQ9c54PDPPA4fmZH+4f+Xg68WlZeP3mHVfXt/z7v/l3/MmXX3F709M6w76z2ByZHh9YlIYsMiXDGPAxkNpW6O9i3HUpmsnRF2OQMUpjXUvvWuztq1Jk0zJMJyY/MfpMuOg1v1ZhlzCGsq0QEyFK/gvCdFil0RmS94zHIx+++Yb3r6/407t3vLnJLPqK334beHj0nJ6fCCownA6EMJc8QkonJBFOJkaaTnJ9X7+6Zte1KC3s7rwIc6qMIcXAOJ6lvesyS0GVFzYohSDGOQSUAWelEh6taK8crrO8fv+a3fUVVmWW84mnwxNJaa6Tor2+41d/8T/SNT13sYWw0JiFNJ9Jj5qIJmrLqOBjiviQ6OeJu8Zyu2sJKXA4PBKzwmTN+6++5vruNf/xH/4z//rDt/z+29+RkuemP9HaTKdbHA1p8Swx8vGHR2YfGYYZpSK3e4V2BrNT+AyHIIxAJHE4PvJPv73n6nbP3dsb/vSVAd6vczMXlsiWxT5ME7Nf+O2//IG+7/jq7Suudh1ff/EFxmg+3X9inufCusn4iDJAKZKwpjSzkOIGW9hSCflveE1+lnmklWgO6ovwPxes64tmANXAbPIsq+GuAs4FhNbGEGu+0Mospouf28YlD2Qr2pD/5ifqF3KpOclsCaKVJdtIzaQiqFTSGwqg1NWybgKJG0lS2I/VkFZw93JDlR9VZimX57kZNA1F1QCmaWKeRz5++IHD4ZHHh3uG85HT6cgyzzw9PbLME36W4klnheHpu2sBVF4YhBgWYhLA66PItmlFUW4QrcicMz7MwjDOk2jxVkaR4qQYI1GOIGF/raouIry0yFkkBFJalbhTTpIdWtjwjR2v0nkX366A+DOnRBkpbIiIk72qVBQ1ki29VEDyECf0OPJheESljA41RKu5vr7i7u6O1vV0rsclx46M7g3KGmJpevLx00fO88D+VUvTOe7efYFrGuIykWIUJZKYmaaaUmPIIZNOgeE88MPzR87zzOE8EFGErESHtmtxraNpG/q2oW0amsbirOSMOysMozEGa0GpSE4zkIh5kQIqvxB85Phw5nweWQKELHJiOWeG50e0zhiX6RrD7fUVbWslN9RKl0W/TPhl5vh8YjqfGcYJv3hxYKzh1d0Nbetou3ItrlmjKTKTAzlDIKM1uKIS4qywZUZpdNtibqVwr9ZCVEZRKUXIgn1Clo5TaSppIFGRMqVQVBbz5ormrUtZXXq5qm1s0/Gno60Jra0AEWFTVoBsjEJbQ9NJ9DH4hRikgHplK1MkzAtKiwRN9Mua85ir5u+FLdli1HUtCbBc896Lw6PLxSZV0VsuDlAFYqXFeGkbSql2N04ktLQ16/Kr9x+DpOkty1KiBppMx+3bt1zdXPPu66/od3sOH/6VeQz0O0kBwh4JSfHw3d+J9OLTt2giux00ztF1mqwSPp7o2473X7xCpQBx4vHxnt/+8z/iz8/485HTeWJZIl2fSi5vlfcqBaBJaghiiEK4lfWfLknqSqQYRdM01IIpMd9RlD6SpG9Z7cDK3pJStTcyp5pW2r/OgzjuoeqjRZGA1DUfOJdaG9OgyBjFuvdsfkd1rsoQrz5+XHcUKaSs91BAbyHkfym1+ovBqhQsSBGPtU7CWUvxHpXGaCPtBq0lyB0V8LUwTDOxGKfb21e8ffOOL7/8gi+/+oLeIRR0mCEE5vO53LEjZYUPonhm2w6VkxQ7pGLcM1IFl6RbEwjj2rYNfevo247GNfjk8dGXUOsGIMRbEN1TSDjblL7vNexTNocyrbaNV3I5dhYWp1DWYqvAe4ZckppTkbepE02VL+csuU5t09A4yY2S/NetQk+qWFOZuJsUUWUGawgzpiRdLS6skrHSy7ppW6nUT1FYyXkiZoWbRnR3hXEO1/V011fgF0w6Q1zWkENCFsyUYcqZKSaWlIhZriv7gDYtxjbSvu72BmM0YVk4np/xfmJnFf2a7CnjllMiLB7vI/M8i6NhVQktGXIyqKjXBejnmefhSMoztknM8/hibtbyn1xAYxVMPw8TIWbubiQX17UdjbW0zZGcEqaoHsQ6rlUZQW3OzBrGX/9dgMAysKtXub21/fIzC/Hy0zW8Vo3ri/BP2jzsOjkuK/5/zOT9zNnqR19cTyZXoHlBWmwfk79vfnFRCyiyVZtIfH0Q2/df3uNP3/+6mRUqKBXwVsF5KBJt59Mz5/OJh08feXr8xMPDPcOpgNVl5vn5gF8WSF6iFbsdrkRBlBKN4hruf/EMchYB+ZKjXDtyrevtgjGEOu5lYy2KHOtzzfnHQ5Er/Ezr7y8Z8cJK1oOsu/rFAV6Mcb2Q7Qnm9RxqHcDiq7CmquUCmqMnhwRzWIdPmUzTNcSQyVELGx1lU9JIV6ccsoTzl4SOYJOiMw2t7QgREhGLI+mMybL7KG3JMZNywGAZ9hPaOhYySUk0w1iDKdrUrnF0jaV1DutKow2dSypDDcuXjRcBczmK4zFPI34ODOeRaZwlrx61RkE0CaOhcZq2dez2HV1n2e0anFE4A/OU8CbiJ0PyhmkurVViKnt4IhopCNRadE5r68760NcohVIXzUJMkedSJcVIQKwypQUpihoijaVGJRRZrGrHYglz51wTZH5qzW/7DD9axz/zujRUBTiurKiumrVbk5OkNLmE9zNIHmeQqBiKUshTr6Pag881Tmr2a64e+8umZxeNJ9aSowt6WByhz+4qlyMXUmBFTOUUgmfLnpmlFsM2DdiG3fUNu5sbXOOKDUhoFTFGOh9m7SFPjOcPWGMJ/og1YHQnn1EBCOjssapo42Ihd6iDZl48fpZ/Ivu0PY+Xz6XiDdb0gJyrLOBmUS+/q7QSwoELW7XalvpcKlFSQGN5lrpEE+veUPP+Nzu2bUbbbFPU4tsfl71ezL/1nW1fu2Rc1X91Uv786xeDVb94fvj2Aykpfv2nf0YOgfn4zO3tDW3X0reGXReZh0CKC3EeGc8DT4czHx5PdLsbfnX3Jf/b//of+Kv/9jf82Z/9iqurHePDPX4YePzwwDxNPJ9OJMDtbzFNR3f7Htd2vLq9IUTP8fSEn0fG07OwlsuCn2fGnIg+0Pc9X371Je/fvwe/kIPndD4yTR4fBNw1bVskt6Qabdf3KKXwvlRY5gUfRI9M8hATViu6tuXq+pa3X/6Kt68b3txd8Skm7pcB7I6ba02372n7Fp11qUaWxa3JGGQzVjny9u6G65truq7BaMUwzoQQMMahEHAZgif4hZyyNCRIec2/G6cBkidnT5MVTVBkY8hacdNfsb+9pu+vaVzHcTzh48Lh+EzMoPrX4HY0Xcv+9hrXN2S/oI6PjEYSyUOpjp1j5JAy2Se6OZDHEXdSpHEinSdev/mCu901t7c3vP3iDdeto0+R43DCT2fsq7c0dMzLwJISzuzAOLr9njQFjvefMDbxtukxrcJ1N8TQopcesifPR45PHzl+909cvbrm8PCG//nrdy8np2JlNtFqlbJ6ejph9EC3awlK47odV7ueeRyw1nCeR7T2W+pFCffVlrc1FUCUAHTR7tNrSBAuoYQwjTmXSuj1b5KZmGpS/MV31MUxqsFOFYjGAlJjFIBf8lS3nNV8oRDw2QFXw1D//yWKrAxptYEplVD4RSJ+VjW3VI5fIxoqlzCbLqH8+plSbLfGhV4YuctXfVdSiKQ/QyamyLLMjMOJcRwYTkeOzweeDwfuP/7A08M9z8cnhuGMXyZi8CzzsqYFZGrDCFOYxkzwEyhVDL/o+mktrRVTBmuXUlVupOIb+VyIkuulTQOEUmhVLz+RgjB5PsRNEzFfgMOLe405EEvRpOQVlwrewqhKweDWbWzbJOQeikjCavNz3ga4/rrJdNXPVDhQKVaNoE9FNgmskfMnj48nnh9GTDaYbFdwrkxhrjwQMsN5JvpInHbs+pYbc4veRZZJmpo0pdDk6lqaIOS2rcNMComv/vzX4sSHKM61BUVCZdG9DCmsahkBkfF5enhiHAbmMJJ1XjW9fZRxn04Ty7zw3TcfmcaF02laQ6bGKnqTaZxm37e4tqG/7tnte25vb3BO07aGnDxET/COEDr21y3TNPF4f2A4jTw9npmnwOH+jDET6R20fUPT9FgtpIDStcjIYIwDtaUMmdLZLCNrOOXMnGLRzfbEFFaHpaaIbD5uTXQXhjFVBYYabi8h3VTmihTzbnBwXeAXTOvlKkzUSE9Gq6IHXTrs2abBOkfTtnJ/1qFzlmKjwuZlItPxtJ6juk0r06aQtJrVxxIgudm9zUYoJbcD0lSGLIzxCspQpaHThQNZ5ypCmOlVV7UAWp1WBjbFM9NwIiePdZpXX31Fd/2Ku/dv6fc7wnhmOj+iGLB2xpqENgn0GZVGPn77v2Mbx83dDca1GPNG5DqnTyi9o2kMjRpo0kB/tefq9jUhJg7nyJOH8fkMCpzLa+qEUvWpVJAqHRZDLdKqc+lCIaqaW5Bc1ZQl753KwKaSklTBYzbClte6BlXnKWhlWLQhKU2IQhIYSgpiFHuVlC/XWTpWVYejat9u3kCx+XVMilwfWnK+cxHMy+knZuIve/3ydqsxMQ4zOSN5koWZWjUlSeSwkMJcjLmXvLEMyjruXr+mv3vD119/yVdfvuf6ekfbOBYFPkfmcWQYBs6nE0kpWtvhlMHljEWhjWhtOmtJ3kieSAwSDk8RnwIKI8C5dI6YjwcWv4hXVYyYUpLL6ZxbmZLKnBkjkFInkR7aHmWGLA/aGs1+v6fvhQVQ2uCTAmUxVvIjKR5nDBGVM1aB0xqnNcpJHlXTOBrnqNNqFektGoJbByVDIq3dwnIuzGbJ0yJnYpIweC6bnNYOZ1thN1CkrIhJEZKEDWOMJSwiclRLkIpHezF1VDG0zig6p2msw2pDjolpGonDQDgP9Lsr9rtrkYGZJnSONBoaBUGBVQ6tGkI6QQolZKTWiR5SEtZHBZQ2KO2EoVYaYsSPJ+bzM8PzAaUittHM40tmtbLlVR+1GuCwRFLMLEtgnhfGccYqKeyKiRL2BRNiUT9IK4N6mXO6GsAa3q8M1s9xFxfOKS/w5M8v03z536stvuTd8rohvDzaj5mWn3NcV1C8Wrz/uoubP/ulZrW+vBbWUH4twnqJjfOLA1ZGMZZIQvDSmW1ZFqZp5HQ8lEr9Z07HI6fnA0+P9zw9PTAMJ+Z5IkXRRAwxlOhF2aQv0ilkQ42suo85U6uQL9e7qWwMao2osIZaNS+f0cZarLnDXGCCz0airtdUcysvVRvW3+v3L8e2Ut0vfnABQ6gjAnllxmUstmvYmI0KWsWhy7mGjrXkvaaASgld4405yyanNCpKKDABSSmWkNBz4Hg8scyBaRJlmN3VHuscnRY5OFUcupwyOYjcnUYJ82Q1urVSwJciIRrptnThhOWUCPPMNJyJKpB1FhYWRywALUYIHmIoxUawspfWarpG8kSbVmFb0DajTJaKwZrPU3S/dXZYpWi7jDKGeY4obYhR07RB5oPSGO1Q2bLMkRQVKIOxShRWtJGGKhfzICu9Nh+JORFzJCRRp4kprGC1jqOMilr/J6OYXzol69p/OfbbrKj2YV24/ORav4zZVmCoVFGRKV35akMTU6Jdl6H8ssbkEIk1P7IcetWULud/qYSzzW2Zcj8GLXLf1f5y4YTncvpUnPy8Hv+n7lMpySGuTq02mv5qz/XdK/r9jqZtWU4HlmUiRl8aPFR7kSFHwnwW5YqlIQJxmUFntLZoo1BqwM9npuFYooPXWOfYX18zHntM04APUBST5Hld5mas/OhqVyj7z9qUYfU90vYs6uPJm7pAyhfyebmcq5AgMsYXlnl9vurFV6phq3OoJixUZ2o1Lblcea7z7qden9mt9T5W4/eLXr88ZzVEHh4OTNOC97DftXxxdwU54ZQmzRPn45nl6SPT4YHT0xOHpyOmveL1l1f8u//w7/nNf/dX/MVvfs3d61vydCYtM34aGE8nvvvXbzg+P3P0M1jLrWnpssItC8o4ghf6+co16HngNA4kP+PnkclHhtmzf/WW29fvefflF7z98kv+cDrw/PQgOYwhoo2max1vXr+i6zr8eJa0griQtUKpgDWwu76hacRjrg81R08YDrQm8/Wv3vNmp9jvDcotnIIjqIzrMotfGKaB82lgGmd2KtFqxU3raJoOe/Ma1+25vtrRtY1opQESvtd0nejUuUYktcbG4OeF01F0B0PpNz2neZ1ME2CTNGKwaJpmx353QwbmkMDssKbHeV2UBWCaFj78cI87LXw6PKJz4t3ekqcRZRRN43i1v6FHs6ehbR03+w4/Hnn69p7xdOB8fGIYB06nE1FFTodH4vHA696i9nsma9j3t7i25zje48OIlCE4YupJORIo/bHxJCVFclFlnM2E+cj97/+R4emeww9/YDj0nB8eOf7Np5dLQSuMLk6ItSJqlTPLMhBDYjwPaBJ/9/f/QN+2gACVm6tX5Bww+iCSJstESWGmtOVeq1dr4vqa61wNZgVpF8tSo1ZdypSlMEBYtFyqIVkX/YbtLo9ZQU7tsFW84uqZXmIaxZoP+ULk+9Jof2Yn1I/+cMHxVuOVWdUFcn0byFr4mJxK+kCVL8tK8tV0vYcN0KuLzSX4gPee5+Mz03jm4dNHhmHg6fGR0+mZh/uPBL/gl2kVwx7HM9Msmqk1V0qcyUzSilzi3iKlptcwvi49vreNfoOT2mjattmc1Ayz9/K5pLaNuzyPWDoarXJZWZ539Uo+B6r1M1JouKybhRRIUpQFxNGsQFYMeqmALpCFiw1fJXmWcQUi1S272NC5AKzrBRXQUy4yqwtWpBxPmdIooOQvGkQyyZoOoyxmF4khMcwLpzny3d//lhgC5/MICu7evqbrWt69eU3rLNedg5iIp5lpmnl6eKTZ9dx88YZ+d8Xt7R1aSYg554xJhuglvWgcJoZ55tt/+RfuHz4IC2sN7371a/r9NV27R6GIPpKjoutucC5wfR3QKtPbjLHQ9IWuc4GoZqY0sownzuGZ1nX07Q7nGpxtMHqPdorWXtHmSH91R4xhfZhxyaSQOT1OLNPCh28+EmKkuWro9x1/8qdfSzU2pkiCSTQl5gUfPZMfJH2BReaLqmuiVutnau7oJqNXgEYdVC7H89L2qPV9mTmxNNHNBXSpF+YAoHbUEyBTwDgKo6UxjHMG2xhsK8xc0zoUiXmZBGdVReS0OWBKaxlTJVJ/WRUbUbu4VTtaUpuqjVz1oXMued/54n4kHUWJX1DeLWA8loLkWAinbKVovcreFQe1rsNhGkgq4XaOL75+z5e//jOWZcEHzzgcOD7dczw/s8wDtAqnFK2SwucwLsQxM/pnvJtJVwprLI09Y2xL2w4s44FxOPPq7VdMPuK6jt/85a/pXcSoyPz4A/7sZXzijFYN0kJ3s/1koKQT1nQ0qyW15lKiUSkwJYrUOCcSbDEREJm7SuBU56/m3RtViopLuhWKNQ0qVWB7YYfEkitRfMi5NE6Q76wOeLWpa7e++v0Lk1vHegW3pcFAleL8Ba9/UwcrW6QV5mWhcVLxX5NuSZG4TES/kEp+qHU9r3Z7dq7ny6++4P0Xb9ntOpxRzDEQlpnz8cjxcOB0OnEazgzBg3O0y4KyC97PWOtEmF4ldIykkEpOaFq7OvnoUUbT9/3aOz4GYWxqD+Fa5e2sMKthgtrYREHpdFITmPUKTBSQYySMA6YU3mil8CkTkiJWcW+lWGbPMJ5FeSBnnNX0RtG2LW3b0ex6bNeXquPMC6Zq3cyKUDPSUi5UNqT8S+QSUpZBjnVqqaJ7p5Aq7pzJCWzpf9y1iVAY5hA8w/GISwqieJtKG5GgKJuWdPiyGLtDq4yKnjhPTOcj8zjiZ1F6OA9nng9PNI1jmSd0TlgtrQnbtqft9thmT8iZqUhvqTQRIkWnL+MDmKCJURMCUrE5jUzHA8swkIKkJoRlkk3k8pUrI1bXuinqBM2qoRi853A4MjZzEX539H2HUYau2xGKRqbkNMUN+Knt32WnlC33sGKCCmJkeVf27ZJFqD8vCJLtx4WtIteco7z9rew7lzzbZyv051buj96p4PPlm1ywNCtirlBzZWQLl0e9WnVx0FyNI1KQmZOkrOQc8d6TSj/3ZVl4OjwyjQNPj59Y5pnT6cgwnBnPJ3yY8fO0Mtsh+DXnVK0gC1QqRV/lWa+C/KVndaqNMXK95sunsrHwOQl4SOtgXh5z0zheAW/BiX8892orkEtlENc0j0xZ41tVVoWf6xxYMcbL/1ef5wpvQ7iO7zaoL+/6xZkqy5XV6qQIWDVQtIwlrC5doGLMK8OajdgJt5ONq+172q6l6VpxGBuLCgmahPaekCM5zjyPz3gCuYQhtTZ10RC9FK2dx4lxmZnDRMie5CV0NByPIhS/y2htyl4TSxW9RRmDUdA6hTFgW8gqEU0o4cdAVoaYIRRAmVUiIeooZi2CNCRsUUwQ8NW2DSSFYWaeFk6DZ5onpnEippmnp7Oor5iJlGEJkt4RciLlgE8zIosVSnelTaJtjQgVhYVcNnaT5dwVp17iODEFFdRuKTi1uKoW18kH8stW0VQHXBe7KUoylYFbHauSeqTWpHZeMp0XHtpFoGWj3rjwiV5Myc9du82WiALJSxu3Vr2/PMjFO5tBVcVG1GhFLs8jhMi8zKQCqpXOoAIxSardcD5xej4yDjPBB9q9pEW0toDsKDbQZ4nALDESUaAiImw3EbLB84B2PbtXJ66dY1+K8vquJVlFrLJeOZZ7+/w+Kgv5kpGmrNPV/mbJEX7pjEPVx11rc4qDUII7pYtjVRmqufkXjnneXKGXjGgF1MUNSsV+pbiO91Y7k+GzMa62bRutHztQf+z1i8Gqs5b3r+541EfmKBWiZGkx5qwmTh5/PhKmkeg9/e6Gt1/s+OIv/4I3v/4TvvzTX/HqzR02SVeI8fDEcHjmd3//j3z64SPffPstwzwxAbppSPsn9j6w212RvZdOHoBJM/N5wC+Sg7pEmKJniiOus7x5+xpnDPPpxPl45Pn5SIpx7dOec6JpG7quZTprUgoS4gCmeSYDN7c3aKNKFyIRRU5+4fThB/rOsbu7ws+W+9xwnBNRWZKSvrxPj898/933nI7SVu2273jdN3R3b3C7Pfu797i2F/3EFDGuKV2Fomzms4A5nyI19KSySNSk0mo1poS/mAwy/ZVoEbYNNkdYRjF6RrO7eo1td+z2rwk5cyyg4MM//xP9zR1f/+YvabuOXWfxWRHQaOu46xt01+Nu7ng+PPLdN7/j9HTPw4dvitQXnI7PxAQhLXx6/CDdnozkeba24dXde3Z3d8wK1OnA7373t8zTSO8SYNlf7VEajkNkjg7V9AxT5P7jPZ++/56nP/yryIDFTE6BEAdS8i/mZoqZ6KVAIitN3/W0jeNm16Ny5nw6spxHfj98j9KG/uqaruvIynK97/n1V78ip8D5+MS8zDyfni4MrCqMR61MLVWVeSt+kLaJ8ueieCJC8UU6qToNl52lZNGWXNmCBmW/2ADStmHkQrCo1Qa8lKspYfiKo1R9WwxCsYvllV8CZgWKVIBmZUvK1V0AolQNYN5sjHphkDmFiIwAACAASURBVNS6yaWUOB+fmeeZTx8/ME0jDw8fmaaR+48fmaeRx6dPxBgIfhGB964XUBfEiZ3ngcos5iJcrdfiiXIbRs7vvUgSxRiKoLsTkKGhth5cQVlla7Ssl1BSEFYTWpzaVCpnq16hnHNjrwthhE5bruolx1U/n5KkK8SySedUC0OB0iP78ts5b4zFJhdU0hTKeOpVh7F8p+DdXAXRXzhDeW2dKzL2K+e2fr8+W8nPbtDKCdkWYZ5Hog8sszQ8aXZXmLbh7t07mqbh+uqa1jlu9z2useyudqVQxUCMpGmSzmHKc17OfP/0DfqosY9O7irX69/SJGpL6YkBt0/M55kwRz7+/p9QSnN3+5rGNajCTLXtDmVaTNNitBSuKg240tQkeXKO6Cy6qsYI4J69ZvIS2dHJoLJZpRdrc4+2bbHW8fbtr+i6Hd2fO3KI3Lz7hseHR/6v/+P/ZBxPfP/DWVQAjEgWptJNKgHOWfq+obOGK2dom5a2ayVVQktVt7UNruvR2jGnQEiJnWmxaJKOZJWY00JUpVMVZW5rJYyuAqMK+7Y60kXDjExrX271WksRWIqJHCs4lDlPqVkASGEBbVaR/KoWQHFi4MfMWCHzLjBrmXElJ3MDkZ+BTaU2u5sVtaX1GqZegbR81hhh5SvjWvWfdOn6uOW4Sura4XAAJ/nM03zg+dkyDJ559Hz7L7/n0/c/MJ6O5Bygbeix7N7tMY1FR0uKMEwBpTReScfDTitUjDCdyXEkfvfI8exJZs+vrOXtF++52vfcvb4iPsOUBlQya0RKlYTUlfwojnZNo1Dr89sgpOT4J3xhOavDYowVGTV7kYqx2tC82khJiShYIkSkmYLBoNb9Rhye4qygqGkGKUlxZsiIgUi+gH8rUle2Mqu5jKfa5mJ1Slbyx4Cyn1vNn339crBqNK9vd5ADz3OQVne69AJOoRjhJPqkuytcq9nfKl6/fc3tqxtaa1Ap4MeRtMw83X/i+eGJx4cHng7S/i/EVFp/KXTZxKvHFyv9nBGJICv97Q0KFZa140njWkiJZRzxixcZqlK5K/kfen00uuRwrVWjSobIvKiCFI1V6Rkd8V4xjhPeW3yA2QtAijETFs88L8zTDIgR2u13XO17dNehnXRS0UaXitXiEVVGNdVimqLnqTVaOaINa7Xyuq4pG4zStNaws5Zd17HrOqwx5AxGO7R1ONfhXIfKGV001XJKqOixOfL6uqfre7TKjFPt75wJfsFZh/RP0SVkl/B+lp1amdK0QLTrzKghi8KBdPFA2pUai9MOqy3TMnGejiwhoHWDbe5QRhN0JufA03BkOC88PR44HQ+kILm5SiusUTTOSgvDy1dZ6LWC1TlH27ZcNcK0NEaY5OO4EDP4YogPxxMpRo43expnuLq+wU4j0zwi7OrWspYLIyuAbuvyk8gFuVT5qy0XsQLQlXlYx32z45U5ecnUsjJwde1XiHuRPl8/Kb9fMm6XyKnuRZcnffH97SgvmJKfecnZ5AOp5DnGArDHacQvC/cfPzCNgwj1zxPPz48s88zjwwPLMnM+HVYDlpPDmotWw7WQrFriy4u5pKXrWGQJR0o+ZvH6VRkLVcJU+XLMLgandIWrbI/YhFqUVVsTXjLIrNd0+bxePMOL37f81DqeiY0VqvegLsa0DncZ4Xzx++WG9eL3bQ7J/FBlvnzOblwy/XLGKrwkBFylpBKV/BEG2tC2sub6qx22abi6FnH7631fJHyaNTUjpli0bANhHjmHCW8i0SYwkHQmUBUJLt0uiSglnckk6eqVLDl7copbHr8D47LopmZfiiMNOXiSFhuEBnwmpCQttIudss7QdhatjMgrlUFMSWxjLoWDqeKknEg2MpwmolektqiZxExM4lykDNMsKQjBRrTOWFuAYwiiQOJ6rvuW1/s9TdvR9H0pClViY63FWmkCEA9PhEmapEQ0WhpX4ZTFaTD761IAJ7ZaF7Cqi91eCzlzWsFO1179eJ7mMnEEi6z2hSwqCFEVDW1tSCEgnQfLASqbVtk/WCMha9bBT5FnFwbtRZ5qvmAZV2/wAqh+tkbkowXMJbW+WSPq27nkVRtbaCNpWvM0cno+cDrOTMPCOIylYr/YtaILXE6DdgplFE5JO1ptN/WQGCJ+ikSfWaZMs3vm5umJu/Mb5nlmmkbG4cw8S+G2IqCSR5kIuoJ2VZxxwFRAXsdjuw+5b13WmdhPRSnvNVkwwdrilzVaVm1PKnZwk8KTh6Z1TSeqAHc928W55Rrz5m2v86U6EblEp9dhWyeb2J/tbbWN1y98/WKwuuscf/0XX3D/0PPNpwFrDF3TYpRiWSZUWFApsr++Yf/uHf3VlRi2XY9tW3JamJ9GhscD8+nM3/3f/4kP3/3Av/zrP3MaBpKRULW2Lc619MayM4bGirC8955sFLZR6Lahv31FCBG7ROYcicd7rDbs+j3D4yOnpyeG44nZexbv8aWfvVGipVjZVqUzjTEoBV3jyErRdh1t2+GarnjaamXGzsPE8+mMcQ227RlnGRy/LJyPR87HI6fTCdtYXvWv+OLL93z56prnZFkwax5sBcY5CECNfhHQXzZM5xqMsTRtj9aK5+dnfJDKPMnMU3TGsbOOt1c73u17rvuOfdvSOAvJ0LU3NLs91/s7XNMxe9GYM8Xj3BG5axR//Wfv6XY9j48HnhbHd1qxBM/hfKRfAm33Gp003e4anj4yzGesc9imIWVPiJFpGkhpIacdqWlRWQTJO63ojaLXlilrHp8/8enwAa8DTdvx61//97i2JVpYwsLT94+cH898+48fmQ8jOQS0AWcVu67h9npP3zQvJ2dZAc4auqbh+vqK66sdX7za07cWHT3Be/75X7/nNEx8fB44D5nn4zN91zH7mS/eveFv/pf/gel8JvqFJcxMy7Ctt5y57FwUY+0+kkpbSiXFuyaRdVqBbIwJdNpYVTZ7LcB0Yw2qNNlLgMMKVmW5p3XBV5Cx7g4XoaCXkboLtLsCVvXSUKzHr7tWtfqfAdrVwMj1iYceOQ8j8zLz+9/9jqenJ/7L3/8tp9ORaTgWBQxho5dlLg5awhhD13WQFcEv63WEwqxVkFk76VT1g/V+UpS81vJ5XUKoOZWGFqU6OpYK5ljE1Cv41EgorRb3SIei0oa3PPsYEinkon7A6lx+3mnsJSzcXjGmwhTGlWHYMvFkTGqNbYGJ60ZSx7jmj8kp9bpZredflQrkh/6s8UnlUteGKLluOJKKpBG21iRFjkUOz0tOoOs6bGfZX+9p24armytc09A10sika9uyyUqu8HCSotbHUtx6Ho6E5Jn0mdwkGtttLFKuDFx5Hjmhs/C/MsZWAGROxKjY3+xoe8ft2yus1Tw93It25lyYxiKbRSqqHDHhfWY4hypvzf7mitdvXmNdh2t26yoqMQVykWGqEZCZBdTM8dM3qyOsUEyTtPzWzqFDyzBPKDIt0LSO3fWe6BfG4zO7bs+X7/+Er9++5Te/+hPY7clX1y/miUKhFg8+MN//J4aPB4bxiEqJ/c0Nrmm47nrcruPtX/032F0HNOsM+WOv1n7muKRtPVTXs5qHnDNh9qQlcPL+gkmlKKGUGZsTZENNOdg6G70EIWpbbds1ZNZ813oHAsCRJhGXgGk1ZnllC2tbbJBiO6UoDKve7HSd76iSEhhxVsb78f6jFG7eHxlOE88PB/wcUElIoOQhzhmWiLYKt7coo9m7PWRN9oocFGmKzFPk8dPMPHqGw8w4K6JyNLuOu3fv+OHbb/nud//CcHhiGgJKT6Ai16qnQfSdtRaZM1AkLfKZIYUyHhUYyvPR2pJiltbqJRXTAsZalAJnNSEImC10gEivldTJlDZ5rMuuX2TplEm6yI2sY1jVHaw02EjBs2LWOjxJmlZICqXecpKLLRUAmz8jzDO/aALzbwCrWmt2fUvfNTg9YMqk0WhckQ3KSvprt530OjZWiSzIFFkK4/Lpuw+cDs/88MP3fLq/Z5xnYkpoJ7p7zhiaEhZs+56m2+HaDtt2wtK1IvyvrSsTMBBUYIojfX+FUZoURJszJenDq43B5gIwSFhnaVxDdA6iLNSYUkkDUEyTSN50wYsAtLLFYEoV5xICJisihrlUxI6jSHV5LxWH19c37K93Ymh2HV1uMMrQdjtpSSdxQaKXELc1Euar0iukTFaRWHRla1gKJCXjRu3Ydx03Xc/rqx23Vz175+icxRqLNgbnOqwthWJKl4R3Sa4OKbFMJ6ah5+n+I23XcXg+cn4+rAZMYXBtx93bt9jhyBBn+n6PKwC6TjhTdJfWPOKYaIz01E7TQDw70nImhUlyhHJgyovkdplHMA40LNlzHJ84TxPLMhLiIt3KjMI4jW0dbrfDOPdibkoIRMJTmeJFB2lrqVTp820UV7ueDDwcB0IuY+kVz6cTXddyeB7IMdD1V6jFEOKCKpu5qsLbbAY95Y1dfYFWyiacLjblik43wJov+qhvP9cN4+IPn4Ogn1vbamU6XjjjL0/wb3ptZxIwVwSrc8TPCyF4zsPAssycziemaeK7b//A8fjM4emBcRwIy1QcsG2OABICVXJcCUf59Xw5VaazAO+Vjd4KnEByHpWGvtuRc8ZYUfhIZUBiYUxFu7WmVrCBpVQ+ky4Yh5WJoBKvGwv1k4/yv/ZMNwZj1cXN1SXYQLcALdZ7rie/PLIqn9w6fF3yTD89cpWYYZ1Paj3/9tXKc6g10iSeXwYLrhW7bK2SdPYCuMUuSVgRJfYzpsg8ieTeOJ/wMeDTUsLWuTg6FxN0vcAXyIY1XcMqdKNo9g3aKezOohtDUJFMJNny0XRRLb1S6whrpRImZlQCokK7SFKziEklCRurAr5knRfGrNaHlLEIJVw7nmSjn2fPPEm3whAWxCWo80lJjr+BrlE4nUhBOmsdjweU9ygfqDmnxkj6QfaB7APjPDL6CT+O5JCIxtB4T8yJToMqHcYkhMo2SdOWRiEV/aY8l0ztVLo+ZqUu8mHVSsq86MgH61paAWUlMVcguRXUXKqlvKj6/9H4VgD7mSWrDvNFjurG0KnSgOTiD/Va9OWRistXmMQ6JVBSVClzNzEdpVXz8enEPCxCiihpEGIMNBqsguwjcZJ5oI0htQhYDYroFctZMw2R8TSzzNIcI3jpsDdPI6fjM8fjieNpYFkSITtUkjU2zgshafqe0uK7kTEo6hs1SXm9Zb3Nyc1W1Nt+ETcRYKnF66qpF+umcGkYCo7bClAvHvrGilTv7WJcigNSlHtUKaxaC7v0lrKltiNvx/3x6P/R1y8Gq8YYbq9vmMeFTn0CFDoZnDLsrSNbS3KWXefYXzVomyEvzKcZvyw8Pxw4H8/8l7/7Rz58f8833/wzp/MR23do57hqLc42dG1D13Xc3r1md33L9Zv3Arq6K6wx7HpT9OsUPkbmxXN1fsP+zWvevPoCmw1p8UynIzEmtHU0SqNdIsYTIQZ2/Y7rqytU9tL9JGeWxfN4OBQdVsduFiahaRqM6YgpMPsF7yPjEjA+4kLidJ55Okq489P9R8ZpIOvM13/yK379p7+mUyIW7Jo9aIdyXcnnCuQYef70QEqZfWfJSTHPi3SvCNIuMgaPXwJaWQnDKwSktq94c3vN+zd37HYdu32HTRmTM0pZlDbYrkM3oiWblCIqRVCZJS4sfubw9B0hnPnb/+c/4pqGeZ4Lw5vQ2mBcx83rt/zmf/prHj89kLViHo/c3LwlxIkQRmwR1SYnYsiEkNA6s28NfesIT/cMwxPLdMRPZ3yeWJTnzMSsZ07utzRWYVTiHCPfHSaW58Q0i9YcDRinaTtLe72nf/MGu9t9Njc1zlkUSnpoTzMA882OrhEtRNNk3r+5Zdc1/HD/SFgkL3icIt9/+MjsPbf//Ibb/Y6vXr9nnk7EVNju5KmLO+ct1CahxZJ3inT8qMLdKUmbyVjCi5fg5lL+KKfK0l1ILF0alvK6cGA/396334sdSJfHqX9X2/G2EJP67N/F2y9epcgoJobxzDRP3H/8yPH4zLfffcvz8ZnnwwPzNHI+PeMXzziPpJSLNJQUvFQuUiktxZpaleIlX8TFBTDEotlX5chq9y4pVtrAmnMtthTxGSNSchl4ODyxLDPTdBLZqAr60/ZsRYtXUo+klTHEKMxNutgIVi5o8yDqKL7wT37qJcxh2gq0yjG38ci1ZvblplNDdGXMahRm5VMvtDdZAeyPpgy6ytms+c5120jrPWUUSSksBqMM2pZqbivyRdaZ0nc8gfL4MJFSYJnk2OM84GNgDGMZH3HWY45UmLNuivly7l5uYYVFV/Xzcq2mBd1kbvZ7ctF5hMw5C4hLO0XODpvdC2egPgidkdaxQUtkLCqsSSR3EsH/rACDylueXZ36aypFUeoXhb3E8/0RPwXG80wIkedJYh2ma4DMsixYE7G0GJu4utZY41mO93yaz0yHRynwLFE7rQx939M1LT4mQkx8OtzzMD7xdHjGz4FbP9I2DXdTz5W/5qs5oDpFdnKvyntyTKSlaGMPE8YZ2l0vzyRl8s5C1b5FmucY69ZnL/JLtUBXr9JjNRS+diFegaPYMJ1LlTgUgFzmZWHiNifpAi2X+ao0kk+9russhIOWBVEdWm3kxDlJmklRyaIqxWpTuPgKUDNFR7i0Jo+SDtE0Ds/MvHgePjxwPJxZhoXoI72TKO5N19I4Rdt4jMqk08wyIqo9StHuWlCKhGGZ4flRMU+J0yFIRCcrfFiAwOl04Ltv/8D333/g+4+PInOl91LXkGE6DChG7l5f05VObtYaklKolMBvNkQhNlRqG6RphP58HdUKvCxAVTktBcbxwgmuc7sYnQ2LVptz6QHIos0g+tCqxIMqGF1z3lXRXS1Add1OSsGeWhONir2SyPAGmn/Z65czq0rhnJFKT63RxtH1HdYownhGLQM5LoQ5M52i5J5qxXAcmM4j3//hA4+PT3zzzbc8Pj4xzDMhZ6yWIiZDxqhE07Q0XU+7u6Ld7+n6nYjwNp2wtn2zShWZlLFtxLQO1zd0yuGnkRgWar6O0gqrrOidls3MB884jcxlcUci3ge2Sjp50DlJ29VlyiLi7IMwSzEU71t620/ngeF85nQ6kkh0fctu17Pf99hk0Tmi91cCVG0DSuOHM2HJaEQYPC9SLZ1mYRzRkncashRa7XY7nDO0jcEp6JRiv9vhnExwU8TVpRhFklViCqSIdHBRgNGobITBzZlxHMgZHh4+4toejEWRcX1PtgFCFo+/5NJCLlI/FrIFbbHa4owt2oel2CkWI6K0gHKfUDGgc1jHJBdQEII8y5Ayfomb0Sqt2LRTmMbg+oZ239Nd3WDb7sXcXAWhkTGJQcbTh8DiA6kzGK1oG0eMkdurHqMV6TxIxa4PjMPIh4/3zOMVrXWQA8Z2aJUwSuaB9xNJsbJ7K2NWcoMU0haxCsSrCkqLnXjxjwuWdWUuNiB2CYS2z/Hib6u26cqUfeZtr6/P3/gJVqMesUpsJSmi9N6zLDPzPEvV/vnEOI48Pn7ifD7z8HDPeZD+194vLPO8ilorcmlRq4pWYC62q4TxKrtTniU5k1TdcGQOqbztkkYZMKpEGTTOSUGNc02RxqGAPRHcryoC8qcCfHNe0wyCL/daxuSnnsofe5J/7HWJcS/h2eVwrYxSzuvPNZ+MCxEZpS4UIT6/mgsprQIo1rm3osQK1l9ey4ujaUrhj9hv0RmX5gYKRYisIu05Z+YwSaQm+hUsbFC+Hvezp1Y3qQt0rbYLpwZvBS9uoH07bpXL2VIzVj3dC6esoiVtJS1AmyI9Z8p36+ZZVlRen8K2Itfl5SVsGlLCp8ASFkJMaCtRnfZKQrBERdc5bN9gdMKgJGxrNN4kBrVgcmQOpaOi0kxqwoWG6TyxTJ7TeGJJnqAiQUemLK2he2UweeTT0w+cllOp70D0O1MmB9EsljxThTtJS1elFHfqFbubdxePRlqq5mzkbi/ItM2evOQrX7xT7N0KPCmAkop38vb5rKA2LFCqGst1zdeDV5m49dQ/MW0yklNcL6RawO2683ZcWTQX3bg0yWd8DC9SgmLMeFU6VxphNu0YMQGMiqAhBdHm9VmIHGUNNlv2XYdVkbTMzLNnHGbG08Djxwes7WjanuE8AIqm39H2eynIyol5mET9YphYFo8q6X9N4144dNUUrLRCYeRfEqVis1NUJQdf9iAfAsHHrXvXxbKrklmr452397ZBl/9OOb0siVAXvyjIbOlN21Vdzo9tFGvDgLUq+Re+frl0Vdns28bRaodtO27u7misYXr8iIkTejkx+Mx8lBaWUSuePjzx/HDkb//2H/jDt99zOB2Z/UJ31WEbEch3VirYLYZ+f01/84qr12/Z3dxw9eoOYxuUaXGNY3+1W0VyldJSVacTSiee//AdT9/8QXqEI60WjZb2o1mLBI7SivMwME4T8zQWMXwBoMZabPHklIIcSqh4OrL4yDwtpdVplGdtLPMw8fzpkcdP99x/+oGb13fcvHrFq9tr7l7dkIp0Vv/mHbbfQxGiP3yIJZcvoONCHM4k7/HTIjJYXU9KMM+Rpu15c/cG1xj63hLnkXA64qw4D84qAb0x4H3AkNDKSBVptuj9TsBfEd3HaCKZw+GR8+mIdh3N7ord26/ou5Yv7l7DsoAXmY9lknAuKaCBxjoi0u2itS2tbVlCwidhV0Unw2CVg+DJMaPzgs5B2g1agwiNJ5YpkLwiLZlpKkV1GpSTiW0SNL2jv92ze/2a6y++ov0s30trgzWi4JpTYvESlhunCWfB76XJw27X0DjF1+9fcTqP+HlmXiLTNHPwgb/3/8jtzS1LyNzse969uaWzmqtGM5wPHI+hAKq4LnFhUCtLgBTOVTWANZF9SwtISXIK66vmJm4W+2IPz3AZnsmFcarFECtgvbRA9SDUt/JLw7L+/SeMRK2A94F5mRmngcPhwOPjI8+HJ54PBw6HA+fzmXE4sSwzPswlzC4sxjzPq1Sc0pq2adbWfrkCFFXkepTkaUnVfXmmKa5yT9T8blMiBcahtcWZKsDeFAk4ufwUZ2LyUnSTFpZZgJQrXXlc18rGtMzEmFl8unzsF5sB2379E69/E2DNMmaXgHAFqrUSnurU1LSRCuozqAtGNbGyz5dXk0vrH7VKULFiwfWYSlKg6r3Wn4XEKk0CssjPOEXWiqR02dRFpaGGhCGTdEZah6/x8pdP6AJMvHhiK5CperKKKuEk1fOKbftM5boiG5jfnqIq2a2qgNcKZlB1n5UR1aZC06p8IN+VslH5W1m2bGLw5XKTRnJ7I1mBJzOnxBg9KSeaXYtrNbfvGmnokhWusbQ3O8H7Wu4zZZiBmUmYxFBckAxqlg388O0D49OA7h3KGhYTCC5yyidM0jgDC4Hf/v7/xRhbtHpBugNlUBWABQFEfkE7i25b/py/4P0XG1jVRtQw1jQmtbHKNeojx7zMid2KcIrGFNQply+e+yVQRclYF2Ub2Yiq7brQjC5ASelNsWKzi/W/isO7AqS8naMOYMrSZat4GpJjK53FjLXEKTGNnhDl2zHLv2EK6Jx4lSJYRbNEnAZ3SiRVIiRGkWaHcYZ+39G6Ha9ev2dePI078fRw4On+wOOHT8yD5/Q8MJxHdLFbN6/fcfvmPdkvpOD59MMPDKcTDw9PpBgYhom2bXn75g7nXAFzmpwD69SkMJllzkKJvKRM8p5IJijZh1LOzNPMMi9c1iLk9TiGlGozjjLCqoDJRCn+krmVSuc9EMLKllDZOl4plhSizBr1KcZUlX1rBa8lnyFnYaJ/qUH9xWCVlIlzIC6hiPBquq7BWUOOHj9N5POzsIQxMMXEFDI/fH/Pp/snvv30wOMwQtk0uqbBNZbGyCK01mFtg+ladNsKC6glZ9LYBrT0j277bvWiRV5KE/yMnyb8PDGPAzGEYsgKu5ASaa06VQzjSE6JaRwgRfadFRDmnIQBo4Q8ValuDZO0x5uniVSkimpob14mTucD0zzgU8Baw77vRZNtXNBI0UZlPW3JrXRttxZ5ZVN0WpG8KK1VaXNn2V05rGsE3FuNc0bCyq0UW2Ul3lOOkRwSOSayNRijUEYKurIScx7WHDORlhEzX7xhrWn7HW0nsio+J3wMDNPAp/t7pnEk5YxrG65fvcJPZ5Yx0ziL1RqPMIzeB0JILMvC4gxJGikTvbCuNbzpjOSk1V7ztS+2KmL8GIWKkmuljUJbW4DJ6v6vL0ns3jTnTJAQ1LQsuFnjfcAqyUFSSnG977HW4H1gXgKnccHHxBQDyzRwf/8RP+9pHZjrHd3tK1LyLMvIsijiElHFAG+cjCzGlNVF61QunnHeACsXoOXi95cs3FZpu31K/lvs8iVzwU8v+GqcygdflmLkNU9zidJaeJ6FQT2fTozTwPF05HQ8cjw+Mw4D4zgyTxOLX6R7VIpFTi2sITdgy3urT0WptbNP1UulrItLVqSmRVSmEyVyLNZ1WNdIjmpRwFBoaWUakC5AKRLCXHLFBskdKznUJIXR4HUoITU5p9E/ZShfvnFJ8PzcY/6jr5w3gPrjU6xvrnNg/Xs18hd+BsWBuWSvVikA9eIi6+y8BKcvr6EiSoEHARHqrprNovl52XWrApgCgv8/yt68SZIjyfL72eVHHHlUFRrATHNmOBxSeHz/T0JZEYpQZJfdPY0G6syMyw+7+IeauXsk0LvoECQyszLcw9zOp6pPn5YD7e1zLN8XTzFsgebGVKuzkwpIpEXVO5vWubESJu77YXPHKmbw98ZonWvqzarKbypBrTCr8gS1FWjbP7TYVmN7ucB2Al52RzHKdNZF8lCVoiJFNq1i+oruihRcbXhGEZXsoyqUxEEl+1537HCNxe57tHN4BYFEWnaBuhckUGJwCPArZ0vB27/ukHpdRearcfF307bq9lsNotLn+i78u85XdXebBZXK3IpqOcPWcd4CXflJc8j0dgAAIABJREFU1k4xYIsXfTs4uQj/izRWCT1TEqPLHi0iWwofMvMYJKoSs+gCd6pE/hKthVaBpK9lbNIkpOpwUhqTDS5bHpJFBUW+Tvg54G+eMAZiyMxTQOkBP0tin9KQlWIaR66ns1RuK/udKue3n2ZQFxo3F6dgI4AV8ZQqpfAU50jwxSGw6dmcRMmgAMRqhIRaSbPwokGjKbz+jUpJXTjrLdfBzdvwYDUySxEJKrYpCW3CYc3LuFZ8uqpGrGurFsH4e1Pt7et3g9WUMvNtwt9mok9oNLvDjqa1ZO+Zr2emT58Y55FxGnm9zrxeZ/7rf/6Nv378zBASPmf+8PTAoe84dJbWatqiy9k0La7tsfs9dr8DY1DW0vQHrHOACDPvDwcyQsOwVtE0isu3mev5wnS5MFxOBB+A4r3LUhwglvFQCk6vJ8ZpYrpdICfs+2eaxtG3HUrJ+0OIaGfJMTJPnnGcuJyvKG0le12LB+p2u/Dl20fOwxWfZ5rW8XQ8omNmPF/ougbrrFh7wWON1Fnu9geU0lybhjxPZGXJKqGzyE/s9nuatufw8CwbnlnHIpaQavKeFGbiPDP5G1UPtHEtzmqscxjnyFoRyfjoi6KA0DgSk4B6Lbqqu4dHdn1Hd7CQAmOYyOdX/vMvf6buTu2u58OPPzKcvnB7CTjd4JRmJJJyZp4mYorcDi3OKB76A1lbKfcaxUJFZbpWifxHlsnuo+gDGgPJKpQFnRTGZIzVkjxjzH0hl9ofKZVKYGWj1ZCzZKhDZjy0UvPYCU/y3fMDKSWeH/bMPvD19cz5OvCnv35muMz85Xrl/PiIVZmu+YHDwwNaQwqBC4rZ+wJB66FaDqGsRAMzK2KWczxlWdhlny3G/0oPSLDqrFJPWtnMVa58xOKBKAfdGiYuenhls1HLll9eG2tZsEAFPnK9SAwFhuHG7Tbw5etXzqcTHz/+wvl84tu3L0wlAlEbbGwJp22Sl2IMEvrPqYBJxcJfQjyofdeDEtkw8dRNC3dJDiMx5lIU4CRr1WBsy64/0O32Rdi6JrFEfJiIKTCMV0L0+HkSD8VwJYSInyW0FxEPV85xBaoKyToum3CmKJ7mmmywvu5wzD/6qoAqr7+q8jn1dKiFPnL1cpX3Va9fbcUCsO7JnwWsqlXCZ5kb9e/3MHt5PwAluYxEzMKv1uFOmBeg1gqhUBkXeaQl6n6HSuQghFykbKAK3Vdvf1br++6fsGaNr2tLat6nZY1Rn2YDTOtaygpyqgei/PVXgvhbE6ly8pb1oQuekrVXM5ezkySShw/7Yiw8iFqdE8BljEEhUlvrwEBaIp6L6UY9tFeDoMxra/BKE+dIzgHdOExjOX73RLdraRrRZi01sESCrT59aa94jsVrprUroEGRzNuNsxqMepkpeenxDVwv80wwUN703WooyHJf7/HbQHX93JqQk4rKTt2e6pxY7l76rHr+opcnt7ooYih5dyregVwM4VTOea2MlEZNogvqM8xTZLyGIjWV2D8faLpWooY5cfCeXYocZ2hSQpcEbK0NGY2NDZ1u+ENqCUHxerow+MB4GRmvM34uXHifmMdZ2l845rezJHM1bYuxdqEozbPnNoycL1MpQpHZ9R3Pzw8YYwg1GXsWsOqDgGC9hICyqHjEUBKcq2MEwuwJwUsVLF146Wh89uVMymsS3VtaTs7kpKiqJbJ4o4zQou0mntWUgjgRygRQJUJR1/pqJNbKfJSEPrOul//B63eD1ZwTYZaKIY1zNI2laaSakzFSCWMcZy7jxOl65ZeXK59er3y6XLnGSNO2dNZy6Dv2bUNjhbRti5ht0+2LKLJU8aCAmKq5KAd2CQtW2Yos/Jzh/Mrr548M1zOZRIiB2c94LwMVlcAK7z1+noV/N090XeHBFm1SOXAzKUuIPnhhOGely4STQdQqixRPIXHHFHHOcTw+ctgf2fd7tNKEOTDmjJk9yXXYDLYbME0STlFj6Y9HrFYwzmhrQWlc2/H07j2ubWn7PZlcyj0Wb1gQD2MGmch1ly7DPnmPT3Dsd5imwTQN2jlMEs9S27XFQSn8m8Y1NNayU4k+e5rJ46cB5pFsDCl6rLU415BUQ9ANxrRY22GiQyfHmBNTFMHq2XumeWKcLSEfSNriugc60/B0fEd2iqv9TDYBZ0tYQgvIFC9qRluFThlrtXC5icTkF4CyfaWcShm4Cgzke61uFkoRi2hKxnM5CK3VoCzHQ48xmnGcGSbP62Ui+onT6ZVvXxt++fgLfp4Zx0DIBut6YtKo6DFaPjeiF0kQNqF/adC61hcjta79moHOW0BUTNKFTKbWE3qZibJZ/doP8oYlWK4LpWrJME14P3M+n5m9Z7heGYaBl29fuV4vfPv6hWG8cbuepWqYn6lZ0xmFTkqiD4UXGmIgFXmornXFgq+HsXx2ipLtX8P8qejwJiVeEGsb8QYUjc2Us6hmgPiQyjpLMRNm8aDOfiDEwDDeCCURUaIdcZEKq5gu55pApQRwVTy17G/r9613bu3t+1dVw9Clqp/QTLpFTue3X/kOqFaQvk6INx+6/KKp0EsVr9GvEXR50ixHwkoBqB1QH3o7O9YHzQV55kyRb7p/8gpMt2oTGYSKqN7cs4xaXj6vtGV5xtXYup+p26zk9X6LJ3lp+3pdWUKbbru/X8XE6q4fNmHKGs6u71UVTK5cSJVlzkgpz9IGLTetgvRa3wPkivMkIWV73wLAlKwnrVb/d7fvxbgqqhW2aTBO5AuNEYfN/TjWUHAqz1jbnItHcZ3vb+yv9bXsKaUVBWFqbco8SpsOfPMqIHXp29qLddsqfNHlzXefV1CqtmL4L3vdun8vizdtqE65jH2lnyiNKiL4VT4t5yJ2HyKjD4zTzMvLK6evr1xOV4brQPAzMQb86EurJWEpAKF4IJXKuMKpNymTA5iY0ET0ZZCysVMm+sg8ekjQHY6kKBzR223gy6fPHB6e2D084iePV5Gu7+i6huHkuV0HckwYpbBO8oGi93gN2TtyNijsErWMKYsMJxpjmtLOkkBYdXWL42LRate2RKNkbBI1WlI8orniK0mk1TmX4gTb8ZL+rapEi+2FKs6vZgl6bvnPeRl7dR8UzfkfUa0C/hGwmsRrlmKg6xr5agytMyJCnzK3YeblfOPj6cyfPn7hz5++MqaMT5kfu47n/Z7HrqF3BqU8moQzBmsd3f6I6/YFsG28R5KGKY+dLJksJU8bwzzNjNcLl29f+PLTn4nek5DBnMaRyY/MYSIpQ1aaeZqYppFhEImp9z98z67v2HUNiky4FPCZpeqMnyZpi7Zk5csikaQolUsCVgmhtl3Hset5enzi4fiAAfw8s8hHGkcTI7ZrhZ9rDKZtODw/4duGNE6kydO1e9pdz3c//lC8iZoYI+M0idUUIsl60MJL8TGiUi71kOUVppmEZ//uHbbtsW2HdhYTPYnEvt/RWIs1YuF2bUfvLEcV6VKmGWem4UIeBzCaFGa0M/R9i25n1K6j3/XMh548WvJkuIXIMEfxdM0Dt3HAGMWc3tNqR9M+sMuB756/pxktX+MrQUWMFS+k8mIsGwvRKowFkzSNKxVnigbc7G/ENxWsckzEEJbNc1sJJwTx+vlQKmvputAyxhmM1bj2wH4nnuCX05XL5YafBr5+/YxRgb5BeEfGCU+4PRKSxcQJdMTkxCiceQGrcSvMXfR0F8rAFhDVAzzDb2AcCeWVvWRDpNw6yhYQActBdQ9q6+dl5qI5/OXbC9fblZ/++hPTNHK7XpiGgcvrN8Zx4Ho9SXnN4KmaqEob4UGLDOVSW3r286IjqsjYnVnCV/IQIEoRshBSSWzIMUlVLC1JfM40AvBTSfLKSQ5yJZSbGIvhGSPTeMX7Wag3QbwSIQSCr9q395ClgsIYSjcWA2kR+y+HeR2ztL24jsX6RCjAGklQsY3woZum43DYYf57YLWONQW2LgfGb6DjX12q3mTTVw8kK7DMBU0WhFoh3cLmzCsd5R4Qbj5bpQW4oin7ilrn2x0wXK/LFbCqNYRPZuHkptr4VI+w8j61udemHxbgmVnDvPKwi25sfV9Ndl4aV8Fnvk/5qNeTF2mK4qXeBCeLZqzaHKZKFcoIoGwBVFo+Z6EnVBRfqqqhVCmyIOOWtp7VUlCl1IRb5uD+8UCz64r+KDRdV8pRl/rxpfrZOo41GrNaXbqOHRmyFqCqJLLzq9cyD8r8KGBVoRcjrJaxVtsFsOlLASBbItS6T9XStap04hoRqoBfSvoqnZZ9IotVuWlWLm3IVeaEWlY556LpWbxzUlNKsv99jMw+cr5deb1c+PzxE18+fuF6OjNcb4UukLB2JIWEKo6MuRMpzqwUOmvawpufpkjSGeMTJszoa0THTJ6kDPE0J3LTsH96YrwN+NOZy+lC/stf+f6Phn7/JHtliLz/8Mx+3/LL7DmfLqSYsErjWoc2Gj/NqOhJR4XBosxO8lfGqThfPNoIPVCVksAxgo5FMSPXcZTkPm2EElI53tKVaVEqoTgDFeKhTTljShJizno1SpTcT47PzYjrUqgnR1QpzqQW47pONQH/4sevUcl/7PX7OavIdNbGst9butZCmGSxG6ni4THMyjBhCMqSjeXQGKzWPHUNB2tpjcYqySg3GvrDE67t6fcPmK7DNFLezipQKTAPZ6I2QoSOgW7f4RoHNNxOr3z5+Scury+lfRRJmsQco2TnDbMgIK1p2p6m6RiniXke6RpH6wytNYuVkXMRyUY4jiln/DSSYsA5V/ToDNoYjLVlMzH0/Y7j0xMPj0/sHx6FbK91UScIKGPJSsrbpRDpGifew+OB4CyME8kHTMq4xhXJGNnYUpZa2Ckmgp8JPki1LxQYJ6A5S5nKEDwRI7QCwBrRrtXG0lgrqguHAykGpq4BpdjtO7q+pbWaxoANHpM9OntymJlvFxSJpmmY88CcrmRmdKvEyePAXhN2iDQNtEGR1YjPicv0mWwHGvM9jXH8y4c/cvFH0rePDAGm7IuCgVr4qdYq2k40e3emoW17DvsDbdew05nmzaaZskhE1Q01xkTUQuXwITKHiAsRYxSpVMG5o1gp8Yzs+oYYI+8f94QonN3z6cJ/+9NPKGPBOPa7jn3fFyMq8/h0YL/rGMbAHCJjEmUECkDcamymApCq7BVJo1TJonyrTUW9/jcWYvFaFPt5PTBZvXUCTmdCCFyvN7yfOZ0lKerr16/M88z1eiWGgJ8n+fKiSLEoYaRaSjGjkyTdVCyc08ohE0u++CdKRqopZRlrOCrlunnKgSIhSrVoTGprhX4Ti0A/UlddQlyeebrK3A4RX+Z55aUGH5fQV950UbXu1w2zNLegmwXbIGDEaVOy4M16LlcPaqE3GGMFXBcOdS3HbKxjvz/+2rNagMNy2C/orIbR1d24b2m0i5eMXEqmbid+BdoFbG3uK3/Iy8G0AMwF7ab1vXdtVcs3VW/1Zq3Vy+qVlTW5sCerx7SGZhcDK1OrZqnN5/49Lutyx212fwVUdT2RF3rB/bOsQHXh1bH5vb5ngVarPmQNU2qVFvBWx0KeXS3eKxkdxeoiWj2ny+STSwT8Vuhc8xPqncvNjbNLtcTqlFkKYgDVr1uftYZqt8ZVKv8mty3lTXUi53twIJWvRGqvXrIgxM3emDd/q3SlzaNRdVaXsHGldWzmjVyW17dvDAVV+bWqzGjFGnreAGkUUjQg5zXIVKZxjknoTLeR23Dj5fWFWq3pNoxcbiOX11em20Dw5bwp9/aThM5REla/BQF38hQCprNShMaSFZiCq3VJZvRW4Yl4lWj6nuN3P3C7XNBYtJEo0OX1FWOczC2l+fbpE2EcsCrx9LjjekoE72mcwTnLU8lPmUPAx4BxkyjOpCCGSc6QpJCQ1gbtKHk5ae2YKm9X+mtZJYtxXKk2ZcgX2lmZpaWyZ+Ui6zJGVU9Vuq/QWDabxOpI2U6AMvaZu7aUAm6/toH+zusfAqsoyazfdy1N6yBM0gLriCkzK8uEZcQSlEgbHbqWh7bhsXjvWq2wWoTtjTXsDs80/YH++IBpGlTbCtdSZQGrt1eUMvikidHT7zticFjdcz298Mt//oU0TctApJSL2HtknD3DOKFsQhvD48MTTdMwDDcmYwSsWkvjTLFmJdxoFVJiVEnYci6FC5pGwvQVrFprsVYO291uz/t373l8fubw9IhuGrQxXL99Yx4GAcwFrOYQJLHMWtrjgdi1qCDJDa0xEqa0dVVrKT1bMqqDFzH2mEoihLGkaMkYxskz3i5k3aCKp0rK+FnhyLiGpDU75yAn5tiBAtf1dG1D6zQtEZsmbJzReHIYGW9nINN2HXO+Mecz2npMB9qBjhl3SthrpGkzIWqyHvFp5DxCUBc+9A90zvFv3/8LY7rxbfp/eBk80+wX3pJkz4J1CtVZmtRwbPb0Tc/j/ojrWhqdaO4OMMqYp7KgxPKOScrr+SBzwdmA0QWUlFJ51WtSyzju+haV4cPTgesw8fXlwun1xMePX8nWgrU8PT7y7vGJrmlonOOH/QPf/eEdt/PANHk+nycGXzh/mSJGX5OGClBNlSeUhP7AmpW9rtzfQqnLQlxAilwiF20BQ06J6yBVpX755SO32yAlUMeRly9fIOdSjUeu9PNUwuu+eDjSKuBPFqCaNq1K4plQSaIM1ZqXcL2ULC7OEpEpS9LPUlZVjDClSmljrWR+xkm8ueWgSoVe4Eep1FLFtkOpshRiGfuw9vGmh1ZjpDY5FwgX37wvS1ngtrFoKyWKl/lR5I50AdVt02Gtw9lWgHfFJQr2hyPabMjlpe/UMl/vN3U5htU6pL8a9sXq2fiu1jepAj4XDmoFweoe+K1gVR520XDd9tcCVDeMzrx6nrfTcoWX9bhbfbiLdFXlq+VY1kGBhYp7sLoBX3nzvFtQtvZc/Zy0vE3A8FtEXShbuQLScuDejYGsumWeFL6qLtfpDQCVr6qksDEKsmCCXG6+guHikZJGrMCfCoZLgmvejJNSWKfJFqpW6P0MvjdUKONTx3dre6w8Upl7NUS8fVVN1FSjwHfdvQUaimr8olbQudAaalGAcv+c4gJ+pC2qGBdLRy+3r6BTeMFCjchkclE12M4KaXMF+Llsf/LgKUlC7+n0wreXF/7y1/9EazBGMU2ecQqcT1em6yD7S1oBnJ9m/CR7plJwCw3aGlInqjlZGZJWBGfJOdP4GfHPCRVvdjADQQX2/Y4PP/wTl5dXclRM45lpPHP59g0/zrRdT9O0fCVye33l/bsDx8c9cRqZUqRtLG3r+O7DM8Yo/vbzJ0KI9K3MoZRkLFVOkCDOE1hLNoJfUim/KnaUeO+pc7saCOVskLLudeArZSuLcZ6FBrJIDiqW9bDsZWUsF/mrvJ2TdS6t5uAWNC/El8IJ/72v318UwDoOT+9p+gmskfrHKZA93OKV0QeCseSmxXQ7mvZK7xw7pdmnTJpGhnlC9Y7sLP3xHU2/wx0fsN0emgasuLaNtfhpJKfIxRiMbTDtEaU01mlimPj001eulwsogzYO1Ui2uVczaE02ksUXc8IUS0OUrlQRDB9IaU9GEYIczL4cgs5KCbkYhPc63C6EmAkZXNuyP/RyMEfRDW0ax+6w5+H5PYfnd+ye32GcJASNw0CeJuZ5xodQwkgl9OmkhFuyjnyYZSGVcpQSLhVPRAgBP4344inzPjCPAT97kaUInhw84+iZ54AyGpNk01MqS0a1dcSmIUUtkzyDK5Wu9vsdbdOijSgERNOQjC3lKyH4IBqafmJmxqei22qFS5OjLBDRiWvpekNSV8bs+Tz+jE0at38gGs+T+YDViZS9VLMK4hWtUZ6aOd4ejzSpo40PpDjz9foVlwwdjmF6vZubVXfXWYcxmsY6rNELTyfEiPcKq3JJNDACkGoJuXpAa0XbOt6/O3L0PcdDz3WYeDnduM2R8+g5v56ZB19kwwzfvT/y4d2Bw2HH49GQzYXrOJONWbxy9eDf8q5kY1HoKEg9/QYqWD2zVOdC2VpK+LTcJwbJxh9Hobe8fPvKNI6czy/M88z5dJZywJdz4W1PKAVWy/yKIRD8tITZc8rCLY1hbUtKS5LIlmohBnbRJy5hIq0txkiISqPLgVQ2tnrg5Lz0SQiZ2Y+M48jlel44rdV7K4kdeWlbrBWn8ppIULfdu3kBy2ejKBSQEtWxlq7tMNYWAGpomsKXlwy9cv+wcNNTBWJZlAeqLiRKNvdYtEbv2qCqx07dHb5L4FlX0LWObdoCouUl4TNQRcR+M1/uNvzii90AqvVOK6jcAuAKKEoEEQnZVjCRV1yr2Pjw5W+pAN90d1gJeFnwzxaUVYCp0vrezXxPbz6hPtHdgG6e6NcjXoYk134vuOoO9Km7aypYkqEsAFaZ2pPl0ypb9f5zc03IqrJhNS1OLezWtU3bNiiosmbbZ1qfNRfAW69ZZ/ivukBV8F4JH6sJUZ//bbtXACrSXlkJwK6ykIs1ULiL6u/2e5nNxZmicnoDSt+sh/ovShauOODLXCl7g6wrXQduffYFJ68KAbP3XK4XzuczP/30N263G+fTib5zPBw6ktEE4yRxqcjlGV3LWme00ct+pqCUHQaXFU1W7JICZYiHR8kpmkesSAuUDCapkpm1IcbIfL2Qg5eCQvaR/W6HaVqMa2UGpVIWvLWSJDqPOJPIDYzjyOwD12GgdZa+bUguEmJCacV+70gxM96momkelj04V2NIi/c2lX2SsgZyTAudRvYovczJ7dxY9unypU0dkxodyps1xbpMtyGccljd41C1zAt9F23Kb9/4d1+/vyiAsRwen/HzhHaZHGbieCF7zy0mphAI1pBdg+l6XNPSWkevFLucGaaJIUWs6VEKTLuj3T/h9g/YrkeVjCtTQu1+moghoNHYpmffPEABq8Nl5ssvfyOGJJuKAe0MYa7Zd3IoJiW8Tl2RvBYOoPdzAavSuSEIdSAUySrtRH4hhVlE/283QkzMaHbaYAptIMWAApxz9Ls9D09P7J+e2D0+oZ1oQ5ovX8haM88z5IRrbVk0Aq6sUmQbYT8RZs0YplJPXEJcMVMA6oz3E6HUuZ9nzzSMDLebhDVTYp4C3kdM3gp0i0vfWIvN4lmNs+iuOeNw1nLc7XCukWz7rIjakbRFK1ERiD5I2DVM+OylUIEBlYwsgrjKFjnnQDmu8cqcZk7jZ1QIPM0/oBt4No8YlUg5EKNIfUiO2LoZGWPZtQ+43NOkJ4bLF15fv9GkTK8U03y+n5tKjBDnbNGdFS6qKWA1xoQPEaulTyXhQLwhi+RK2cjaVtO2TtQCQuTldAUS8TTych45T4HXdMGUJL//+Pd/IgTP88Mju37PHDPWGoagSeWzgA3wzAvIBEXSeQEKqycHFgt52QTyCliVHOCxcI6kAIKXzNThxl/+9CculxPn1294PxNnEcevXoWUpepXtmKR+3mW9xUR/VoCNS2Z3OLtEOps3dyljbCCVa01yliUsWjTSJJGOYBiissGKDetXL9MjJ5pHhnGgevtRIyZ4NNy1tVQ0dIdpU21q9J2n1x6j8WAooAR4SwbmrahaVoeHp5o2o7D4QFtJVKSy+GZSjLaPI+EMDNNQ6lMk9eEPnl4MXisFVm4zca/2B8V5LPktHO3Q6s1QSZDAYcLZNi8sxwU9YAw9QM2Dw2LkUvhiy7nCet8WgPpqt5o+bAVqHLvFbuDbwWsFqWK6km994q+yVhfnm3N9lcVvFITP1YPYIW7unzlMn+WA3oBtm+92Wo5iOV83HBSN19VRVJtASvrWMk1YQH1ZdW9GT29fs+wlKtdqmLVsPj2sytGVeSqh1HHv076utaL+XI3wNsfy9rcGgWqjGzNftP5HpDUy3POJSxfQ8YbEFLmRvWk3eGJO+9q+aM2ksdRaRLLvFwQ9Z25UNspEelyflhbeKzb6lfresm1UzZhZ+9nvn35wrdv3/jzn/4stKAYsKrHPjTEQtkxhYMridlZOPM5Y1RRN8lisGmE92sLWO2jJFGyPxKNZp4abIwwBeHWxkzVW0wxMt+u5JRpG4fRUlkvG5FvDNNI8l6iOM6SUyDMGasTymXOw0xMgdswQm7oW0fKhpfLjEGz33Wl6MO85mkUj6pEe8XBZIzFZ5HzUwX0iydVxiRT96StMVTXjczHus8rLZxjzSbpsu5p27Mp3bsLqtG13esWDKzVukZ/J1CFf8Sz6gyHd0/M40AMg3AkvXjGRp+ZfCJoR8QXcCAZ+aeUCDlxSYmJTOp7jq2leXjm8P472odHdOOKazpzPp+pLmNjHUpb9m3Huz884ZxhOJ8Yb1e899im4/npiXAb8Oczs23Q1mFcg3FRPChG0zQNrnH4aSRMIzknrHX03Y5dvxO6gZ8IpYqU6SwmJ+GAzjN+mokolDMllGkWzhxa0fY97W5HczhgmkZAkBGSekqBeR7xt4FcdFUpi8IakakoTn7IJXs9RLyPQq0ISTKfx6lovUZeX878/LdfSmWhgV3b07cdMVfujUHrRjKnvQj5W63AOZIxpFJS9bjvaJxUItPaFI9VQmtHsg2m6yS8ysRtmjl/OWM6sL0S6Z/imQtRlXD7jFKiLJDYYbImqUAmkJLDB/j8t58JecYmRW8arJqJOUumJZZnfcTZA33/A5oOow5Ms+c2WyY8AxO3+Y0aQJJMb1/UHLLK2GwILqGN0AFCgGjkeAo6YXJVBlgX7HLAKQRkWTjsOzLPaHshhMz5OnO+zoQgR/XnL6/89aef+fzpFWss19ETUmZ/OGKbhs4esQ5yFk/lPE2EGMnaSCWwTXbleqiVb7k+n2ysIXiptjVKeP/8+spwu3E+vTKOA+fXb0zTwPn1Be9nSEVeKorhIln9SvSEgeDnAkyliELjzOLprhuReK1NRTrFQyFSYrrQYVShywBScc7I2tJaFa3TSChV5WoIPudYpKr8ot4xT36pKlXpV2VllGsqBKqobP13WMMJ0vxzAAAgAElEQVSJbdeKEXZ4wFonUjElkqGNwTUt1lq6rhMuqjFLta4QvHB3i4bsPI/4UA3FUPbr6lkujVCSyTvsuiX5QwaxhNO0WcDEJpBZvr99ynrGb2Cq2v5FLd6Nephv568cRAWQ6gJ6soCmFeS9fa2E6bTcPy+tVOQi3r1evQhL1feWQahgc83qT8udFuyymdtVAD7n+vNaenUpe7uFWrn+fj8H1h6qB+EmeUnL/9TiqdT3far0euXGsBDQWEp85gqPpfEas1oNSi2e1UrJqMO3tSPe4Kzyu4xRBa/yPHoBBmvf5qVvpMADJLV6y6AksbGC+Cppl1RJlPrVawUlW+qI/CR9JLSWCkxqD6/UFhlvtRGPMMtd1rsVnnG5hTKr11SptMi2qcKRrwCLGlWqwKcuhwwxBM7nC7fLhcvLK7fTBT/MKJXpm8yhdTzvH1B2j7YHPjW/sEPLGo+B8/XGOM/SRzGhU0TnTJsSrdbslWZvDEfj0CTsHImNJvZHOaetJ4fAjhtHF3lnNLuHnsfHHtfsaPsj3737wI/f/YFsJdL717/+lc+fv7BrMo2FmGZSDpjGkhIEf2McI3/+y0faxvL9+weaxvF47Ok7xx9/fMDPkksyjIFvr3Ppt7SoSiRB/5Igm0K1SlBFZWmhtS40jWUmlqWgS4BASWRQrzGh5T11hShF1llsIl3n4bqvLeZJPd+Ks7BGypTeevL/x69/wLNq6B8OGKeYLh5mBUHEdacp4pMmaUtE6rOHAlhvweND4ASMwD4qWix2/0D/+Izb71HW4CfhYt5uN1KMaC06oe1uz07B8fkAKXJ7/co0DPjoae2Rw+M7JnUiDaOQmLVDG4+xcjApLdnJrWuYp3GRozLGiJxW15PCIMLmQbx9RmUMmRQ8YZ4JPpK1QjeVd6dEjLyI9bq2w3Xypa0QsaUEqC5alp55HEg+0PYtxpqF96JUKpmaMtixHJLRexGqn+eSWCXhfz9HLpcbnz5+lEM0TKSHJ5xzy0EhGntWQqYxoBALUlklWfVWOKu73Z6mcTRtA4CfS4UmbUnGoZsGFTwpzox+5jze6POOh/5RNlYlIvgpKnxIeO9pXYM1hpRbdNLMeAKBnC0hZF4+fyGkEYOmMY14KEtYxSjDgz3i7CN9+x50Q9I7lDsxBUvOHpU9k7/nX6UkgCwE8QrWcpCxWJ0iW1VyooCkkxxcZuXWrQtLmGtZC1DrlXCoY8zcbhPzHHmturAJXk8XPn3+SvSZFEFZi7Yi69Y4RWtEO3bOkRwVs5/QKaFtUzSUoxDZK8Vt2cRXmzRlKQk4z4FpGnk9nbheLnz6+DOn1xe+fv7E9XrhcvqKn0dy8fjv+n45bFLOeD+jlaJrpKxuLMlMKcn7RdVjTarKOWPQ2CJNl5LMWWMMzrVY22AbqSIV/ETOibbpRd2j62UjmgbxTZVQuhhlmYToAvppJKYg9AQvHlUolJAyvlvf3Nszd+kl2VsxWtO3rVSC+e4DTdOx2x2lJGbhkbtWSjZbrYX76kU9xM+jlFeeJaEyFrA6h9XrnIpgcw0j1lCqC5ZpGorM3to6XTi5td0qqw3F8h653QOy+qNaDobNMVFv9quNXpV/p3AVK7xfb5zZhv7WRJYqj1UKJ5Z1oReAWz2RFaxu77n4vZbkpy1Yldcm8axSDjamR17uIB6cDWFheS7hoFbQBr/WfCuAcetJXc5h4YtCFXgql1aQWEFsBaxbY6GC7rw+7ToecfkstVRp2gDPTRMXT1K+23GKGpWiHvGbkdyMX+3LAllVLU1cDJO7HkvrpVBC7W/B6gam1IZVL3oF2otnrYDvQlmQZDGJItS69VUBXnQz16heHe/ViKn3rmC/vkVAF2TJ17gzaKAazsWKIcUkhUquN8aL8FHDGGga6Ixm11iO/Y5u98Ru/x3GexhuhY7ni0Z5KIVREjomTE64pGhVolOW3sDOGsmfCZFsHXQ9PsNJz+A9bYrsQuDRKPp9x2HfsT8+8fDuB/7jX/+N//3f/4PsNNkq/u//ssc0f4bpFfzAFAIkJYWBEqQQGceZ6/UmycWt43iAD+8eOR46vnt/YJ6EzgXw9bSqtaQs9JUEC381xbj8bGwWTJDXubhSLcq8lUUma79wctfQYB2pCljVMr3zJiLxdg9Tm/+VgqOLV3eZd7/z9Q9IVyWmSQTC/XhjGkcuQyBqB7sH4jQz3QZ88MRQwI333FIU68W1aOt4+qd/4fvvf+Dw4Tua4xHbtGQFw+1WBOvl4UII2Kbh8cM7jk8P6OgJ88hw+gLK8PTuPV13oLEWmobU7/DzjGkG0u3GHEoFm5Tpdz3HhyPnlxMTg4jI+5lxvNFYhSvjYrRsiI21OGPE4lKafrcTTqGVak3bY0OhMSj87cbp80d0CCjvCbsdxrWMlyvj5YbOisY1HPdH9gchVQ8nsTJySoQ5EH0kzhE/z9wuN0JKTCEWfkoWugIwxcB5vBYAEERGaNnAwTpL27YCRJ0tkakkNYeVojXyDMfjDmOk3nopPiGbhlJk60hGMc8D365/45onvuWB5/aJPmt0yJgJTqeJ88vEp89fefl25tj1dE3L0/E7Ds2RvT0Qibz87Quf/S84m9EWmncHtOl5NoYAPOuOzh3554f/hWxaZr0jKM2kDN3uSLN/JCQI8fqbId8ERUdUoY0YESFEjF6reSwlP++OQe4WrBiUq5Va12vfN3x4/0BIFF5RZJgin7++MvsJPydCzKUGtWEYbjw87PljzLTdjiE6YlJMsXhnbEvT7fjDj/8Trm3Z9TvxWGrRCvShyKJ5z+l85uX1leFyYricGYYr8zRwPZ0YhxuXy4l5mvB+IqdIUzLVrZbnSXkNJm4F0oXjZLGmQRQAUuENzzRO42yLsRWs1rnVSOlC10hm/OIFkXK/sx/wfkQp4XNfbxe891wvZ9GPrCU7lXiMo5cDI4ZE/I1o5/J7Obw0a2Zq07VYa9jtjjjXsOt34jEtottt3xdpGwUqE5JH54CoKcKYJYt4GiemeeR2E0mseZpKsQNRJ6jAVeS68nLwbwFASlFKzW7+TQFGqYWOIl6xSm+o0KwoHuQqRXWfeJDJC8hZcsg3msoVVNTdSPaAWqWrSP6pyvlbE6bukpJUPWZS+axtGHx7mJT1k+vPm8EqYGtbcyoDqhYqKJ67RfxgC/wqAC0ew5rEtMDKe9x3d26WD9n8sv5xrZpz/1rApVJotEimbg/NvD5nVaaoBtyd+D2wlIZSS7cs91h0n2uP5M3cUZUDnpeb1Wz7/BttXj4ql74qIGX5fbOvVdkw+VS1kC7ubyb3Evm2UvmwFPWokSVVisygShSqgt4MORUVAFXNqWIoVMWQhWZaSuWSWcJHCxWozFdlSqb/mqS1hKSLQ6SC6ZQi820gh8ija3j/9I7/4/CBr1+/8V/i/wt2xhwGPjx0/NA5WpXp5hFrLYenR+bzFX8deN/0XJNmiJ6QEsZELJl/RfOI4js0+6RoStU8FzwERTs10LS8+/A9cwq8jq88xADTRP/8zPMf/5n3P/6Rf/73/413D488PT0QYibGRNf2NF3H7SZJ102baJxQQWKCbnfE58DlciWkzPkyknPm4WEkk/nlkxZgjcZqI/J5tqPfHQumCdJnulSo0nGdlGVsFimywt8X2S+NM4V6EQs5pagBvJ2JdZdZ6zAWQ7VO5ZyLxJrMpYUWo9Z1l4tht9IIft/r91ewKp4Z0Q4dmeeZaY7ktkV1e1IEny5S0jOJ5MJYqgrlnOm1pXUd++cPPP7hR7rDA67vpSRc8VTEuPKBUilDsTse6PY9JE/yI364Yrue3eE9jeswJSzvXCN8VyMht5oxnFPGNQ39bsd0G4t0RS4Vbmbm2WFbqfShtfB7XAENQotTtG1DzBCXg6fimzrgEOaJ2+mV1lia4iazbZLw/TTTWYc1jr7r2HUdyXtmpMBATiIsHGMkhUj0kWkaCTEzV3HzDKHwDUOKTGGGkomdcioblAy80QbrnKgAGFMOoIQ1wmfRzmGUouukIoqPRaal6qMVwdOsFD57ruMXzsy8MtAGTcgPmJjxc+JyHfhyGvhyfuHb+UTMA/vU8vz0HX2/Y+/2xBz45b/9xOV8ojs4XOf47vk9Rin2OpFQaPvIvn3kx6d/JWB4iYkpyzbsmh7b9qT5xlKi+O0rFw+rAhczSVfeZdqA1PLGjR+COuOWA1rdheAVgFY0reVw7DncJs4XV5KCEpfrjXEameaID4W+ojVto5imkYfjgZ0fGbzFR7gMIyGBx9Ltj7T7A32/L1JukrTlgwhZe++ZponPnz/x8y8/c339xu31pXgAJ6G1+JlpFEmWSiewpsFag9WrlygjwGnzlFC8/846WYMpYEKUsqaFQmOMxli95DhYJ+WPjRVOdp2cURtyTvh5IOeMnaUDh0EA4DBeiVEqVFHWWi70jVyMsbc2xGZ0Nu4ASZQyWtGVqMDz0yNdt+N4fMS5BmtFlzIp2Txr4lNMUjNceUmW8kE8umOhVQzDjeCFv5vK/lE5vKIlW72pm7YVkFLlc956sDSqJCqWSaXqBi2/b32cd8+8PPTq3LhjmG0krxacVeSa1ibUA+VXUKXMcUFIFS6+7fMKfu9B6frtHpyt1wooLc+Z1+sreFzfXD9Z2pg3h97WV/Pr1r9paF578N5Ro7bd9OvnX/5yD8gr8qw7xZb+sCT3qM24bZD0r+2szfMuQ7/hplaUWrFcfnvd+qWkYzZgOi9gdZ1LKwBYaTPqN/fMXAArqUQKUkYbYdHW6lrLTKhAswxGqhN/032Ke9Bf27IYLmvHl2vrvTeTKGdI4njRpv5dL0A/xcQ8juicOVjH0Xb8+/4Dn9yO0y9fCPZK3Cee944nZ2gytN6jjaHd7ZjHwKwDvW24NXD2MMeI1RpL5p+ygNWHlGlR2ALWTQqoqGmDxzUt/eHITMT2GRs8t9HRPz3y+P6ZH/75e/7tf/03OmvZWcc8BMIYROXIOmJKTPNM1xkaqwhZ1Edd29GECDdPSoFp9hgD0zyjteLlZKQSY6GwGS0Ux/3xgXn2pHSlVgfTMRYZtPSbC2Chy5SwvzHi2Igl+qWLo+Otsbf+vPXeb2b5sj8mcqkQuE6J7dx4+8P/+PW7wWr0nvPnLwznE7fXz0xT5DR4utby8PBeQHx+IYbEPM34GAjLTqXYH488Pbzj8emBw8Oepm3R2jJOIugtXEk5iKxteP7DM/vjkefnJ4zKfPzzfyWnWARulXDdlGJSiphnMLkcQJF5DoyTlzr1MTKNI8PtSvATKXqMEQ1PmfwRssZoeP/8jCJzfOjRSomlYhJNyALgXINrmnLwZXwFvMPI6+fPDJcL8ToQrwPffR/pnx7YO0M47Gldh3WOw+OR/WEn3rsYmWMQbtwwEuaZaRiZxonrZWCaZ86XoejGBtF2bVrmeVrEx3OCGDzjcMMQMSphW0e372laEbEX6zcVuSxD51wJ58omJpneBnc4klDMSZGnwBw1c0z4NBLVTFYz4/TCt2+ZOAfiGPjrLyM/f5q4XCaGcebz60jXWLT5mSlMGDuQ88w4fiSGCW2OGAPhltC6YZc+oI3jeHxH1+459B2zMoxBkWPg5sdS2QqUBRV5m08hYfQqMaQV1hnxGKNLwqbQUnI2ZS8szLO04cu9xUpKvOZKg0kJqzWtNbx73OGM4jp4bmMoxlni9TQyToFxTsw+8cunV15PN07XCdc4smqQBxEgpYylee2IfqLrdzy//0PZlBXTNHG5iEdynmdutwvXy4nxemEarkXrV4jwzhh0tyM3mbZrS5Z7I/MjB3JKDONITpmm2UnFsrYFFCnIhmadLWeuFepN1y5AHyUCzjFEUkw4p3HOlHqlmXEYShj9VpL/hA7gpwspZy7XSZIT53gH9CpXb9ki8gpbZMdgMQS1URhDoR5YDvsDXduy2+1xrqHpehFON4qQAnHagNOUCKmAyEKY1eRSZCIQQ2CeZmY/M05jUUbwxFpJqLRGtuOSPKa0AHZtaFoRbjfO8f6791jXrBNTVQ/GrzfsfOd1gyqSXZN+VoS+hZGJLa8StaSOyvv1PWLMWaSA6kmy+gTzcr3wD9e0r9rQXD7vbZhOmAXblZKWsZM/VTBynz2fF9Cyheb1s6U9KlftiFwwXHlvnTPL94V0sPbzAm7Xr+WZVWXl1oC/XFdJAVQ9UiQbfAunV93YN+dqRcGZBWCvz8ViIJa7LlznxXjIWfpowwVeVSDU2qe1r/NaBEDatJZ73uLGZTHVNpIpqevb1qMQiorsfUky8ynlZbVi8XIiXrC01fHdPOx9+LeA07wmysncLwobi21QRqBGHCrHOmppa9oAISXRH3JmHG7M48Cnzx/pjeWP3//Ic9/z4fmZtu2YjGZIXzmnP7H3mofhhk4BEz3vcubZWCbrmJ0jOkdMkSFZAqIUY8g8ZkWLokNjtcK2LdlZZiPJddNwIUVP/8VgneHQGXLb8O7hCP2BECAX6T6UIiiYVWJSgfPtzNdvXzi/vjJdrjwdWlpribOiavMnJAcGMs1OY1tLVC1DMNy+BKyCg1XE5Nj3B56/+wP/8//5f3G5jnz6/IqfA9PoMeMVPch54acboIqxXe2TIGsmi3c8FNm2nHOJvpU1oraTnIVjuqzzOsUWFkGZO+UrL+VVq6ccMrVUd0K/Scz6773+IRrAeL1yO525vJyYIty8QWeNbnu0KwdgzsQgyUGp8LnEO9lzOBzo+56ma4rHTy+ySDVEpbXGWsfx8ZHD8UjXtiQ/8vLyBa01/fFQoo7CtfNxLIkkVRsyl2z6WnJRsubCLOXVSFLq1JiymRZxXKWg3/VoMm3blAGRIIY1hqwNuoQXc/mbcCVjkfwJTLcbO9fQ24b0dMTGjtYa+rbFNQJW27alaRtU4ZPEEEghCjd29oS5lIQdJ8Zx4vJ6wcfAFCZs09LtpcSl0XrJoK9lL5XOaAPaamzrijakWrw0RoMzegGrtYqFiPVqTNMTlcYnULYlZi2Z+jkCEaUTMY5cb5nx4rmdPD//MvHTx4nJZ3zI3CZP6zQvH850rcaaEzlPhHAh5YjSPUpb0iwT3+kdzrYc2oPo0DnJ/bXKiWXn1eIxUQoBqm8tRVX4imbNStdaVk/OatE2XYTJM4ulfqd1+Pa2ikUCx2gJh+/6BmMUbevZTYFh8sw+Mk2BGBOTl3l/HWbGyXOb5+KdFGmwttsJb9IYJiv87K7flXKxmhgz4zByen2VKmp+JsyTRDOmgXkcaNoO27QYJfqfol2q6fc7nLM0zomSQ5SKc/M8kRCJNV043NVTL3qL9WErH9UtFISUA6mA3lxKpBojxPpEJsQiaeZFvSPEeZG9SikxDrFw2H+7l7e+rYzsiTXcXYGesVIoouksjes4PhzZ9zv6fo+zUuIsF9pHKp+dU1oSyELxji5Zx2WvEDWKWPiysu5iKZUYsyiJVO+SJJIZtG3Q2tE0HcY6dntpg2tbHh7fSdLcbz4dC8jcGkTrk9dvqv63XL2qIS5vkqsKWFg8lsXr9uYNJbHo7TwvAJESdFbVP7L+PW/eV2+a395ncdlVvuNyxzsjZOVEbsyRRdZg8wkLp3f9lLvlvkWGtV/L/zcpVcu/rM96/9P9FlJB4Hqf3+qFey+tegNU1Zve27ZesVTJ2o5RShv6R4WBCl3/niu1a1XOWMBiXpPglttSu7mO7f0z3L3WxizJVxXI19HLCLc/1zbfuWfvzILyfgEqVU96CSMv4eD7Bix/q9JbaQVBW2lipc1a7McHLtcrumnotGbnrFCoXMOPVnGZHWZ4oTtNdKcJlUDFjNMWpw2jVsy6OjY0s9aElLFa9rYmyd6jayKpcyRn0EYTVcaHGaUS3F7RbUPbPeCdYXc84k2LT4iOa5nrMWcCkTlHJj8xDjcpSjRNgBRMAk1KaikRLcmrYJzGOEvWjoDmNiTRgG+rmpBmd9jz3Y/f055HptwwXCdSvhEzuFIyPoiQbDnvqjGZqdzwSgcpmHOZq1vud537ajN6d1MhZ+GuLvzmumuVubXMN7Xgp+rZ/71MgN8NVoP3nD5+5MvHT/znX/5MdA3p4T3PuyOHcSRl2B0OTMMVV8AQwK7d0bU9P3z/PT9+/wPPT0/s+72UR4wBXw45RUYbQ9cf6PqeP/7Lv6C14uc//VdSCGQvGbcpWkw06ARp9oRxJk0zYRiZppssMGOwtqHveooiMtMwodBY13A4HAhtS9uI59GWAybHQbaN6nFAOB7jNGGahkPTLBI31kWaxkpGf6YkO3lyjrStoW81fWd493xk1wnwo3gzK6csKyGKhxhEimoceXl95Xod+OXnT0yj1G9PORNJKHPjcjkzTRONbUgxkoiQFH4O2J3FNAZtjchQqVLKVElJtlrEIKdQqtiKeL6fAzgwTUPTdewPD9jWsPv/viPkif23dzidaRzc5oGfLidev0x8/WXk+hoYznGRD0q9IsTM62XC2Bs+nMhppFeJrte0VtEYQ6M7tG6JKhPzjS/TJ1x2TO47otpzTd8zxUQI81L3XTip/GpySyJA5VhJprZYqiIN5YPFaEn8M6rytGRzUIryXQ4O4c3VQ7zwB7OE0BttwNZ/Fw9ut2tJKbM7HJl95nIN+CCUC6Xgcj6LFuDpJtxRexWZLWuw1rC/nmjajnE4k7MixlySfmJZ26IL6DqHSjPRKw77nv3xgbbtSmlTymYvICz4ufRVKElNWYoP6Jp8FuR9YSDlxDDIoZiUZP5bY4WnGSRz1kdPjiKFEuKMnd1CszmfLkyTVFVLKS8aeiD9XCtL/b1XRqx3W0CwsZqmaenaTrQfFSUUH4XqU4zFmCLX4XoXdkxFQi0W/cFUPKohhGLJi0Vfeac5yWHiQyRlRVQturHYnaNpO1zTs9/v6bodh8OBruvY7Y+0bctu14u+crfHWou2hsO+53h8ePN0sJRuqV41csm+/nXH6LurC3zIbxOpNuAHdZ+0tfEMvrXp7pqlFNuShyJ3KDSapWX5LQTbLr6NSwWWeyXN0sfyBHE1RNhwNpf2VSBdDjdVEeAK5JdDsrRt4YnWPlOr7qwcqmnto1waRbV2V/CmKn9484xpaamA0SVqfe+6XC5ZcCVrX20P9fWSmpBS+zYth3qN6qxvlztUT6pa+ixSKROSBCPSX5a86V9IhZ6TdcW3vzUTJEKpMqUynTRCVbm5QiFaSp0uoLjMScmjWpL4Kpe1isTX5Jm82Zd/3YTKqC331roUxBJvnHGu6LdqiAqlLGBJyeKj5uwTNsPnviWZHt7taAbH47eZdvrCbvyJxfibJwiR+fzK9XKmmz0uBHYxYnIW6tM2BGItyhqaw4HUWppnw2zhpgNRwdmKapB+aNDHZx6//w/Ow8jp64nz6crXT1+Ehucsw21iuE0obXl6/4Hrt8+McyTMkyR5BUcMisvlwvkaCFEcZMfde5Td8/zjv2Os43IW2tfl8kr2I2l8xe1fOL98ISnH0/tn5vkjp/M3/HTDT1dijJJYtXjz69hL4qeiOKsQuoApeRtqS3dEQG6dBbIWt0ZdEidDkvHOOZEodIQyl6jRT6PJ0ZCV4D1V1GR+z+v3c1ZjZLxcuZ5OfP36jdztMN2R3nt8iGTYcCSLQLiSpKJdt+Ow33M8HmjbFmNEkzDl6gWJRStT0/Y7ut2e3X5Hip7L6ws5ZrpuTy1/JmGVLNaWD8R5Yp5uxDCXpBhVhPDtUqUnlcx9Yy1N0yxcV/E8riLgm5UEUA67iLIiIGz0OgimJG+I2K+Azkz13Eqlrr51GExJrKln1mrJ13BrTJEQo1ShGidu14FpmhmGERTooomZgifFhNGmbMQyAWMJnVRZkEypllR23KpOoCXjRv4WQqkAFIR/qBXaWrrDjm7Y47oe53pcLtq4xjFOicst8XqKfP3m8bdMHPLqQHAivD/Onss4MU0TOU10nZH+KkLxRhkUhkQmZs8cvwio9JDUzJwfmCPF+yXe55TS/0/Ze/bKslxpek+4NOW2OeYa8jbJbs1MQ4IwGgH6/x9GBgJmIGgAjbpF9JBN8pLXnnO2qarMDKcPKyIzq/a+3Zd5UKdqV6UJsyLijWXetWzY1j2l6msZQHn1T4jjF9/fC7P/3BdVa1S1Coj7RJmAdZl4RW50sRqALdmOjTOEqHAu4n3CGHEz8eNUKMTOAopKNKRzIn85R9ppLCYY8eEs6oQ5Dak1AmxlzAuPa9s4ur6laVpKhZnGgRgEpMWi2aza87qySN0l01SI00zZVIn1jbG0TSOa0eDxMTAFX5zmFzA4FReb0+nENE7F9zTPIB3Wbf0voNXSd7VdG2doW8dm0xV6HiXa5ahkYtO6aCwSOcTZjUU0RIX+rfqWFo1qqCC2ko+nCi1KlL4S1hBrHc61kv55s6Pf7jnsD2x3O25vbthsthwOB7quY7fb0DSOvu1lHjGarnU0azeA2jHA4qtavp0ph9SsRlrrDJdLX5nI60krU5xa0Op8zUu94gpUFfmdb7DcdAaqrz/0UruYV7/VDfi6u3/KJ/cl6K2nLH2zft6l5lCtRmk9ZwHsy51LW7yK3NfPv/wml/KJS8Z1kddlfRn9PJd0rladGNWqLfLyjDovvdLPF9uZtVaVuhEQOaqMrsVwNAOLVzpxPiowq66oucaozd/XSHEZS2pG7mqeayEvgTW1BnPV66S8RJyva8b6m8ysAMiVrL5YjZTW5KRK1qkS8IUAWJ8SQ84cjUI1lty1aD3SnG9w5owLlF1YIvlAmjxpGol+JAWxbNqcaOahMKsowGiUtZi2QbcO2xmiyyRrCCTG7LEOXGtQXUu3u+EUFH76wHgeOD4945zDNQ3DeWI4jxhj2e52GCdpzoW+L0M2kDXBT0zTRIoKrJstOf3uFm0bpvBMVmfG+ET0mXgeOZ3OHI/PmHaH63dkMufhTJwGYuF2pwBPScRQ+7/StS2AtPbB8qp9VUG8LJpZrVNAVNMAACAASURBVJMFrywpaun7IinLBmCWqyoTqwC+n3n8fJ/VEHj49ImPnx754XnC0LBPipAVOYsJ7jycGccBPw40SnPT7fjs/i1392+42d/gXCs+eMcnfPVTzcIR1vU9bdfzN3/7G6zVfPPPvxWahnOg7TYcPvsl1hQHY5UJZzE36uAZjieeHx45jYHzINHFtmlRuhD0ti2brp39L1Sc8F4WfGtNYQ0o0dxkQix+bSmuFvy8mibWOxTR4raFe1JlxXAeGI4nxr5FJUPrZCKNGWFNCEIVJOlTY8mOpYhoctOQGk9ykuFCN5Z2s+H+888lC9Hxiek8cj4eZWFWsbgBBKJX5ElxfHokhsSb+4Ms+kmBsujySuFMDsL56UPg4fkJXEvo97RTwB1uiClJkJZyMBqcaumbA49Hz/T4HdNjZnoovJmrWT54IQr/8fsHTk/PKD+hSRzeWGxvSMOenLZEY1A6EwmE5BnHwBhHRs6E9IHjMBKSY0wtjz/+wOn7DyR7lgkjvD4J6zLBOSvA2JZ3ow1amdUkLn0oGtVcgnsSsezqk9ZLMIsqPoQaco4lCE9jCyF7zJqEpu06Gu1otpZUvstAs7thHEf8734n2VVOg7jIpIxXmRDOaD3y+HAqm5cS/V12o0or+q5l03ezj+Xj448MwzPGFA7PAriDD+QYRROaV8FlMaGUomtbUOI2EkNkPA9CMTdFST6RsvASu8p4UbS8sUb9QmYASta3lJhCdbcpy2MJMltDgDUUqt/XBclaReMM201XmBQsRltSluxzIWfxPQ9COUeKjAOkMM70UZLtDeZUnwUlxwIGqq9WQijdXLenaXt2+1u6fsPh5pbtZsvN7Q19v2Gz3dK1nfSpa3DOYl2DNZIiWmtTXE7UrJFRgHUvtQTiLbiAlJSXtriY2lVetVRm5j6t55evBbDVRaacM+dnr01el95ruJrnfp2hkEKePW/eWN0rUwR/BpKzpqUuR3le5uT3alKeKylWqppdaQY51Yv0QosKNYPUgjAvicsrsMlZ3KbluwLespmFS3R2Anr1FZBf+qg896LLcgGq5WMFwGtkNV+7KlpZD/T14pvXH9W8Z1m010umwvV5FebPoHO+cJXkRsm5lbZoLpla02pcblzqobQSCxxVgypjpEaJC7WUmvtda3vVDfUZRUtX2lSVR5r6YYVV5hsUQZv9gZG/Zym4cI+pG2CDbR0utux2OxoQi9X5xJ8+fY/b9HTtARUD2oPyGeUT2Y/kaRJQmBJNiGwxkALBR3ydh2JRAFqHNpZmf8A0LZvdLTSG1mYGmwlbz5QTn4LG9S2HQ4/qHSpFwunEw7ffEYaB0+ORd2/e8Nnbd2Tb4GzDV199xZe/+htaNfHNTUvPB0I802xuUL3FdSfcBLvNlq7r+OzzL9gebjHtHh8i33/4xOn4xIdvvyP6gTgceU7fMar/wv7NW9798lf8+dvv+fqbH9FpRKWRbdfSdy1aSaxEjIXeUSFzuhK4SWVpEc4YtLWFUlEJ4BVOLEj+UqLmiEA9JxCRBB6FAktJMK3Set7UZxJJ1c3H9Ubmp4+/ig1gGifGyTOEKBHXSnLn1jzHIQQJlkoRowx907Lpe/bbrWgzjZFgonHCFxNdY0RT2bQdXd+z2W4gR54/fWQcJ6LegHY0/U7SJUYPhROVGMEH0jThhxHvU/FbW1OM5NkPTwtCxFkLOZUUkYXHMuU5ci5dkTzK2BJtpMoZs5rYa0SdQXKe54QQD/tAmDzWFi2sBkoKyar9reN2XnC0FvODc+jGolNEWSspXg8HxuHM5CdSSGhtSLo6LOdZw5Riwo8joMUHLwh9hSrO7IBk7yg+iT54xvEMMeLOJ5RzEg0dwqKtTALQnHFoDDlCCpCmi5l4aa+UC3lxwIaMVYoUFCkacnAk7Ygho0zhClRZTPYxE8YzIcI4PBJSwxijJKKYRjIB5VbPuj6qpqBmU6ovtSxQ+arIVfNX31NZEJbUotfPWy/3dbFQksFFG4xxaLREeGZoekAbXOOwXiYManpZBSGIP7AvWceq7KqV5TKnIBNAgT3jKMwcdaGp5sKqLYhFA5qKCU9ktEw6CJtECpFxkGxp05SIGXzMGKMITs0UXilDLGWSaNE8a4BTugZfAsxUXiLYaxuuI0vrLn+2QJRUp2iNUlZ266X8KUVq2tWa8jVGjyKVFKg16cEKkM1ja9WHWqNxWNfSb2/o+h039+/Z7na8ffOW/X7Pm7f3bPoNu53MV2KBqf7Pr/kyriqfhU3jet5dA44qMxXYXLacWiG8ugAsYGM+8xWsVEGnKuD2UlaXJ13caQW+MlxoRNettxB9X5Ztfu7qOzGdv6YjXEDMUpYZeV9W6AIsX/02Fzlf/bKuneK6zeYa5OVxsySubl3Pqc+QN7UU8eJJF7VjHqzrvy9KIZ+vNwXztuHCVL9IzLyhmGUtX/pzlrqse+XyuVXPdV1kNYOFGTDkshlZfZdZ5tQKoGs91nWtmepkD5LnprjuyesWmdtlPmc1xjLiAlHZ8cq1lQguhcA0TcTzkdaAThtsSqiYISZ5TZ58HpZrY8Qi/uipmKujypj6e8kEZVyDa1oa40rdSpCyTkQUPlmwltQ4tDWYlMjeE84Dg9Y8Wseu6Ui7W9RGMkU2+x120/Hh/Rvi8EQ6TmSf0W2PQqw6tsn0mw1939P1W9q2J6MJKXI6nzmezpzOZ6IfCaMn6xPu2x8Zs6G5ueP5+cjpPKDzhE4jjbX0eVkTU07kuJ5rln5cq3IWrTjUQDjh7ywbvpcSJXeZh/Us2QJYVxrbWfZeF4afPP4qsHoKgWMIPEbP3lq2b96xf/OOw91bxvEsmhofICv2+x37/Z7b+1t2+w2bTU/XdYzDmdPxSRYPY7j97DN2ux2/+Td/R9M0fPj69xwfH/jj736Pti2//PtfsTvc0vYbjDVYLTRRw+Mn0jASHj5xenzi+OMHBm0ZteN8Hng+DXhfcqBbh2s74iTpzJxzGKOK5lTi1YQ83pMRHk1rDNp16KjR+khKidPzM65tMdsNMZXAjBAIoTrCW56PIzF+5Ga3Y9P23BwaWYhJxJyJSGq2rt+itWaMEvgVHOAtO51w0w697Tk/n/j+6z/T9BtM12JJuFZ8VRvnMErMpznGwguZmPyAnwJaPfP8+RfstjcotATNBI+PnjSOxOB5ePrENI2ch2eytvhv/oB72uM1+OFEDgOU7EaZkRAfcM3AzRvD8UmJR8aVWd5asK1i17Vs2oat0TitaKwhRcNxTIxhYvSPGGPpdzuU2mLjl5J28/SIUg2HZstxiHz89JEQHnE3E3qbsDeW9vCKs36hNxE/SQFl2hQf1LJxjCwZvqEGWokGjywaCrKQ32uViy9XOSdlpijZ2s4jHIfEefKEnIloEicSmuE84YO4hAiQkr4Zg2w8ttuWi9zMSsB9DF7M1z7NvLr1yGnED0EIlY0soJeuZDIhVA69mPOLOUAB1owzAKkaSdFgLqAqpYyf6kVVGwbkPKfDFi3lsvCuj1okAayKthV3mabrSsBFxWpShphEhn1MUpDZt6qmkxW9ndXLK/pJNPjijo7SDpSRCH1j6bYHnG3Z7PZCCWad+Kofbtltd/zyq6/YbHrubu+xztI0kqjDWTsHXlxscMpCfok7LmHLAhZetkclHp8vk2+X/ped5gwa1UUk/Rruyv1rYKUuvrCK4rc6gyTFhU08L5uEipMz+SrCfXGCqQBnoVFa1f1CM7rEmC+yeNkGc7uswLXcobCZXPj1VNC3DinTq99zEfWFkLxuHKVSK9/VItMiv6ksoBXayfOTUkW7JONfrbu4LLYGidiv1Us6FzOohAHWrFjVbLrYJBZt99w0V0cqm7IZva4xLplcZELNY7ya2lf9vP6k1NxX0kNzurjXwUWRP60QX8NSqip1AMpU38X6rFq/IjE6XJZby9idM1sVlJnXrXA1lHQFwpU3trRHHAciEK3D+8Cfv/4zp8dnPvzh92yM4d0XnzENZ07Tme3be5rbjng+ko/P6OMz5vxMOp5IzyeJz4hJ5nQFeZIMVGOrCEaRjMIaS7vtUa4T16ucaI4nock7K1qb+TR6aDTDYYtrDnTNW0xu0A+P7E5n7nPGNh3t4Z794Y7D4cDm/ob+bo9uDThD8z/+O37z6895+OHPDMdHnr3m7DOfPzj6p4Hdbo91Dak7cKYh/fiR4Xzm4cP3DOczvnCyT2MghLNks3qaeHgeOZ4GfJoIw5FwPs5JAbbbLX3Xzh2Vi8VYFbctU2grKbzCKQbxWy4SrPKVFK92cKpSZ9bflYyvnBJ4L9rZoljTCmKZf2Iq6Wp/JmL9+WwAOTPFyBgjPmey1riuo2k7mrbHWCfuEUoLabg1aCvk9AIOReiD93g/SbYno0WbutvS9T1Gw/HhA48fP3J6PuI6hXUt1rXzbk9ZgwoCKmOKJSWqpEWNVpGcFX7EKI79laTdGEtgWuiKSp1UTsTiw5dTSf2WEkkrFFYoq5QMzhCEPioV02KMsezGCopQWiLdkVzDsfjGiX8rZUY3oC2uaVFa0ltmDSoYFAnbNWRj2CbZDXUPW6xrVpNFCUixdlblR+XJvvpeiq8eiPk3pzxfk2MUwBEjIUiU+ORHQvTkFInnIxFwT4+kSQjmKSYDiKQ0gPa4LuNahWkMOYn01aXSWXm1ztE5R+cMTtfUpgah0k2QPdZClxUqGzQ9KRnyNKBsS6NbRjVKKjkNTW/Qvcb0CeMuweql5jRfvOp3KSdi1nUunTUDc5tlNb9XYndV6ERiSviQGHxkmBLnKXEaI6cxEXIgokuqWjifxkKZ5mXnXiLQVdmhWmvKs8sOk0zW1RS4LOprLVdKmZCCOKijLrWaJaJ/Vr7kTMyvD/85n/38RYVN63Fe2nDVtnoO1ChT0jV2YdE+Vb9hU3bTzhWw2thVQoJCw5MLUi51hGWhglTqWDSwSkysSul5IdXGoJXGug5tLK7tsbZhe7inaToOh1sBqk2Lcw03t3fsdjt++cuv6PuOm5vDwhxBxf3y7Lm+VU5mkDlLHa+38qot57ZaL//X93n9uqWlLuHkq+fVzYZSc4B9flHWBdZdYMoVpn1ZtjXUUv/y9/nyl+Vp12WoVwmwUjm/Ev8zL5EXLXEBJuff611X5148eNHavd6uV6VVl2OPq2svtZgCpl9m4lkDu0s3mMwrjApXZV3+Kv/Pg60WrG4k1KpuiwZ17R37k4e6wsaKpbQrYHJppl3X5DWr01LOvLJuXjRNXn9Y7iugdi2hZf0ig9bEGBhOZ06nI6fjUbJeDgMqJwYD9twRwoQKnjhNJRX8RC7ZqmKIxFDAmdHCIJRLQKEB0ygwiqZzYMWnVHbyYsHSUWMsGBsw2WCywmCwymGiRo2eJgQ2CqyxNP2Gruto+46ub9n0LTgFBm4Oe7rOQZRkBWnMMEa2hwNJNXTdBm2sZIcMkfj8LCwC5xPTIPR6McYSIJ3xIZH1M9rZkkxGLLt+EmWaj1G2INVCpJb5dh6NZd6eM4+trI2Xnk0rDWntrczMflB2TXPfVpestdzM/X+1Tv9rx88Gq1OIfPPxgR8ej/hswbbsdgd2+xu2uxt22xu22xucNvSuLX6eke3uwGazI3rP0X/keD4TYuQ3v/ySuzdv+Lf/7t+x3fR898//jaePP/Jf//P/yel4IuqendvSOINVifPjA8YamrYhToNEu52fOT9/YhwkPSK2LbQymZQ1bWwhR7ZboUU6PT9xPp95fn4ghInbbY/RmuPTo3TuOIjGNY4oLD5lphDLAilAW2nNNI0Mw8Dz6YR2jvsvvsC4DtN27Pc3bLZ77jYG1+iSqEACzbIyNNtbtOuwXUsCzh9GQs4EVZIOWIfSFmM7us2Wpt8wngeeP35kOD5zfvyIM467u1vxs02R8/HI+XTCGY81kb7p6FzL3e2B2/2eRiuU90TEj288n/DTyPH8jA8Toxc2hzgG7PlJAnJyJk+jRFZrCHnA+xPenLCHkd0vGj6zW8KpIQwNfQ60RExzRlvPXb+nd+0c+CFaNV0UZ5GgSlrPRAE3mqQcMXQ4u+Vm857WepTacA5bbsOWgSMn9Yiz3YVsOmvo2kZS1RZzcaIkCUiJ0U/EJBQxzmjUVtEYMLZQs5R/MVESLOQSeJY4j5HHk+c8BY6jJwRFCDBMgdGH2f+0BvWkkgkml8Am7z0AXdcJt61t5kEsY1SCxpQR/zFtSnSmZjbFV7AmGbYUikhA1IrZSPrfGjiXs2IMuUTmy9ywZr5ZKW7mqcPWCaYuYGW9qmBxnVmqTiu6vKzTIt/WorWma7s5SYdSzBynsfiXitY7k3MNjhItjLhDrBY2BanQjGnlUMahXY9xLdvNAdf23N2/ZbPZ8ubdZ/SbDYfDLU3bcXd7h3MN/aaTTXIhyrZGAkCbxi2RqqVhLifNxb2mtkXVzvEzJ9baYAlPIohWrPRrziV2Pq/PFPr7qrGU+T3N2nJZU5YOmv1WV8izauIqFVAkivb0GluqkgREzbDgFXiTyXrR7s662VluVosOzD7aoi9cgGTOushVibwvZuI0I8+1T2p+5T2vQLacl3IFaatn8Lpsy+95Dv5Ic/01Ose57tW/7kphPpdBMv3UTVnZfCvK/KZWDytlmcFgKWvZCJMhK0WqO+HC/bt0ZpZ71LbJimU7WcHfjCwvgfCcflWhig8hpc4v+STUkiXtApwyg0zIqzFSIHGZt9abUxHVNahR6JKmtSaaQa00p9U8o6pYr27I8vykkDktRqIPTMPIcB44Pp+ICr6332C3Pdq+JQwd0/GRdHwiPz+STk/E8QR+EmDqA3n0kt5bK9GwavAbQ94a4o1YL1W3J6oW9+0zjJ7zOKEzWKMZrcz9qZM12qWW3VsPMZCeAreD5ze6odsf2H3xJYfP3nL75XtMZ6BdZKTrOpqm4bnfMnnPoXf0SfGrY+b5eSCdjoRp4tsff2AYPQ/HM+Mw8PGHb4VaL1bXHQUxSfzJdOLx4UGsQsagUhBfPZXRTmO6FrPp4SQxJRKkJkwapsoTVfGRRS5TkbmyBklQVFMUGIV1J4ZlrqSes4BYGSvFClHm4TIIWaTu5x0/3w0gZU6TZwwRMbm5udGFEkkiYVXq0YX3MySPsxZrrETqpzATaO/2e/aHQwGHgccPP/Dph+94enxkGie6w06YBbI0XAoTKhuiURIdHsMSKR4rj6IMAq01xlpxzCaLFrJkcwiFVzFGT04ScOK98JuGECBruR8whszoJUq/coipEPA+lKCPgHYtXdtjuw2u27C9uWW3P9Aqj9ZxTjcmA1foOIwTbkhyKtHwebHsFHYCWxbTbZmSH3+MM1+saYpDu9bCjVDMltU3tm87NmVn1zROlpEUiYJAZtqwmFaR0xmhtAoaP5zLmibATxgGIMSJZCVRgusc3cHhTYvWLTuj2GkKe/9A1zQ47WZ+Z/Gv1AXwVGEui2GWrFsJMFrup1SDdZpNv8ViMNnw5B8IY8Lo9lI4rxQbi7ZUKKxiEK2p1pCSZgoSiNGUAKua5EEVx7pQXAnGKXIaA09nz3kMPA8TKSliVEw+lF2s+CBXx/UKZip/b83KVr+fJ+K8HtBLHaqWVOfF17P6+1TewvoZXc3gxccVhZpBqprBalrn4C7/XS5dcxFePdb4rJo7XQmqcI1kuHLGYLShbSzGWFxNNDClEgBYuW7TvDhWCDIDxVq/4mtsirWibXuatqXrd7Rdx2Z/T9dvefv2M7bbHW8/+3wGq23TcHNzg3NO+JKrKUtd1i9X+Zs3DbVh1EVf1cCgNcfmT+HVF9/nRRYrqFC1zrMWbG3sr2BjLuCqnZY7/FT8bF79X59S4R4VkF0huTVMXO0TVn9UAKUuzocKYVda+IunvyzbS/lSr3xeawgrlLy8T35x3U9J7uoiFq7IzNLuF2WurAyrDUB1tl3apmqn1AxEX9TmojiXrVLH37r9L39d7Sry5T1eb63rQ82BLnCtBX557r/0naoARqmrOeDlFfnFN6Us88S2aq+VivwVhfTyh1qfICwkKcR5DonjiHYaHT1E4TrXQXCBikEA2wUTSpL0v1mRlZZNg9VEZyRIqm/I1hTrWhT3vODROZMxBKUgalRQ6NGjhwkzTOSQSSePmzx7bei1ZWcdGyM8qjVYth660IMZ12CbFm0abNbc3Era6DEHRhI6B3IcOR8fGYeBcTjOrluSrcYUMB8EW06TWJGtLZatXEVf3JwaRx41OSz98WJuVBc9IO+5joHF3WV2qVFlbnwh82uZWwn7tfD8nPFbjp8NVn2O/DiceIqBfnPLzeGez99/wd3NHVYpuqblsL8lbTpi6DifzwzDmb5t6ZzhVIKf/u6//3vefP4ZX375BV3X8o//+T/x6btv+eM//QPD8UTIhqbd8+UvvmK7P5CmJzwTrt+QrRUy8mnAn0+EQbJfBS8vz8iULcpauq4VAn4nwVTRT4zjyDCeRQsbEzl4coJxPDNNHj96jNE8nztihm8enhlD4DgMGGPZ9D3OOabJM4ye83nk0O158+4z2u2edndgt9uy3fao4Rntz2itRFMZQaVMiJ5oNMPTGR8Cz6eT8LMqLdqj0vlaG3Sr2R1uMFrx7Z8y3ntOz2e89eJcjeySpmnCh4mtbehtxy8+/4r3797z7v079jcbdI6E4SRgIWXGqZj+lUZpJ6TrKIxxoDRpGoq5V4CY7beSGSgUKiwNbZu5uU9MrWLqDP/d21/wy9u3PD18y/n0WFLbBpknMlhXg4vSvFiA7MwMjm17Q1QK7W7I2vKUMtZ13N3e03Qtm92Ob77/M7/7+p/Y2vcXslnJomtqTK0sWVM2MhCDgPlhlDSdIUTaxqDVBmcsKZkC6iCExDAmhsnzeCrR8j4yec84TaJxLOA0xgXoV6qoZdqu0bUFeBmN1gi9WQ3mK+1Q3RQAnDOF69TMYKq6nKAkstIiXHhLogMglcwjRtFWvFV+WnxNF2C2XqirqXrWmGQK995qOhFsTNcZ2saItaLtME7o3+a2KO/jNJCypBVMKRVZyCVYQmGsKeVTKGUl+tQ4rG1pug19v2O737PdH7i7u+fm5o43b95yuLnhcHNXovY3NE2Da9uSAEOXNIQrzkQlFZxBAtIOs9mqVrB+qI1QAevqvxk/Xi3NC/BNV7+IgiLHGesVpacEa0i3lT5MYmlYzGbMm+8F2M7G83KzAt3metWMbKoaLZYSqgwqLoC2duq6r6uPcq3TXNXlmwU7SGni6hn1/FzLovKSnzwv7hu5aP4udk25wNIV8sklur9y0lYrzQwmq+hT66CWDrnoH7W0/ay1K1H1au7ZUp5LOp26oOvKhqFqsJ1BUfXIq+N6JzFrfROi0RUXLV0BdE39Q9UYJ4TKSJX+yHNb16ctHsjV0UAETFWfe2q7lMUk69cKRqYS95f2BOasK7NQFE1ouV6r4sZQ6eKgbJ71fF/pu+r6NGNVarBWquhGLy4UCiRIFS4ATXVJytpLCnI/sO81mxTZhhE7ghmecVNPShM+T6ToickTU4AcRO61zD0uZWzKZKPJSjO6lti1mMMeNh3q2aOGiTAdSV5cuZQC2kRyCt1ZLIn2w0fc4MF1pCkzfhpom57Pd7d0WbF9OqJKSup8vyWb7YuENtube+xmhypa+7u79/gp8u3v/8zz4xMhRT59+sRfvv4j0/MT09MHQnFnyEqCsXUJ6q0tH31myuBaoc2qKdx324537275GEdOYaDqVVRx0cs5FTkvvqW28K3WWaSa5crval0RpRA3yOJXlhXVPSbPAlBuoxblhFJm1sD/nOOv8FmFkEFpy3534LA/sN/v2fQ9TeF97NuOEBJBiU9FTkkWE+fY7nYkMrd3t9ze3kCKDM/PfPjmL/zwzV94/PgJ7z3d7h5b6WKMJkcvadjyMlmWMSRTfqJkyIkkncgmorFooyUCr2lEq1v4T3UxpeY6Sc2LeDH/5sw4eXxKPJ/OjCFwHseiIZYFtuZSd0W7vNtuaXdbuu2WrnVYrebgBQmuKBMKCYIHpeUZIRb2glTSVyKa1QoeygSaZ3AkL5Uzk6LwqEqK2RAj1jm22x37/YGbm5sl7WZKpLD4CS7arSJrdeIr/Gf1d4m2TsUNQhOD1EK6I2N0om00LjdCiL7bEYYn0jQy4ckpzKYAGQhLUslFrqQPrClsEVZJGl1tUK74G7Yb2m6Pcxs0Leoq32oNqqrlru1WIVn1sal0NiFmTIAplEWw2MNCFv+f0xAYvGhV6719kM3WDEVTfR6zplCtBuI8uKnrb9VeF0qpVGHDClWqEumq6qIgwVIV8DMDmTwvALUNcypr0tUcssZj15q/dSutx/kiF3Uhqu4I4nLhrME5U1wAZFKqdUo5ljaLVPqsVE3ZJUOWMZLyVRUf7/pubEPTbOi6Df12z+5wYHe44fb2jsPhlvs3b+Z5p+uEWspYU7JL6Yv2nqUsc6FR40LuL9tCzlEXf/1rR756f4lWL5+Zly8LOIWq/alyM7+vSnatv1zqqC7uKlVcFeKqPOtazSBFLScvgLick/+1dljtbi5Oq/6otfyXRzW317n8ZenK3/W2FexcPz5fvL34XOeey/ZcnlRZCuo1NeZ9aZ0FGtZ1d1mqX1tk1637+iK8ls96n3z1Da9+unR/qHJRZWBN3L6q4U+W46dLxgowvuz7C0A5a9hWAJN1G65qUTS0L7g3r547+7pqNfvVA8VylXAqyytGTIwQJ4ienD2ZJNpSU4FwGQ9KwKpGMBVaibVUW7R2GGXQaLQPQnmVJStmKutydprkJBArJ2DyoAbywyMEMOeIxdClRDtNuOOR3Fhy15A3FkIn9TXLpsE6J0kTyr+m0cQ2cdzvANgfDoQYaRrHaCXNsyZKRj4iKUeyFkxS+UuX4FktMT1eEg6RE85AYyFYyCW2aVn7S5uvkgLMg+Nq7pnlbf2tWvf18j5r1rkc5hXw/rSdrp57kAAAIABJREFU6OXxs8GqONE17G8P/Pv/8D/zN7/5Nf/2735N27T0tsPGPen4hudnw8PThLM72G3pu462afnF3/6Gu/dvcY1G5cj/9b/9r3zzxz/w2//7v/D08Ei72dJ0HZ/f3bPZbCCMxFHhh70I0U5htaG1DTplQrshnkdi1kw+cjoN6N5iXCtRw07TdY6ua0nBkFLgsD9gleYZ4SQ12lDjNpVSuKYhpcT3H35kmDzfPRyZQuQ0TXTOomMg9aLN6bst797e8fb9e7746ivavqfZbDg/PXE+PgsPWvAYNNko8jiSYyJGRbINp5gIKTHFCVSWNI1aeEJjikzjUNKxJh4+/sjx6YnhdBIGgpQ5nU+EFPApzNmbbt/+Lf/m7/6WX331Je/e3Ik7Q0pEH4kqy24MxE+0gKxUyNWVKgMRiu9nlFzv0YvGMcLpCCededQJrQJKZd5uOu7u3/N+d0Pf9TybFkND8DCMUYKCiplaGwF5ZCQJgdIF02k6t8X2G24Ot4w58ymOsztH0oaznzhOE8/DyBQuA4WCj4yDn8eItWIh0VY0lJKIwpSsagIGQ1Y8nCWjWNOI6cd70dAeT5L5w4dpHvzeB3wIiwm+yIwAR4kkRcE0eckaovQ8pGvK36QUfqr3LIwF1ayiF7O/yqkkuECYAgrg8wmikoCzalnKubK05DlYqU4VWtdyLpPEenF/AbTWw53ik2olgUHjJMGGc+L3mclMfiSPskGYJj8nuBB8rWshQCts22GMY7O7pet73r57T99tuL27p207dvsbur6X97al32xwbYtrO6yzJeGIvGxNLmGE7k3wYJoXvZexz7UdCiSoAH41iQqYvwyG+XlHfon4518ySUmWuRrgPm9OVOF+TQVIFUq7ObsWi2uQqnVbPUrlxZ+wytJaaw4gmZuk/qosQAuFd/1p7bu6/r14zxYgLT6Qiki1CKzbVoGKsllLco/ZhSEtROtSpyKjV1hIlMRF6uYkCbU0y/3mSzLF921ZU2NFv/XmqYImASvVh5O0bGCSUXPiDzFzSkl1NijEVCyN93KDuNT/stflbQ0kl2jpZatR/F/rIM7MiUFKwakJcOpd68Keip9/BfC5aK1r36RZi11dFl7LIFW2JXUfeUGbVtIdK8o9YDVoqD7dteovNxDS7y+PMjJrkFOtQ9nQzWVcB5JphLs3g04ZmxJt9GxCpPfStuezIY4dITxIIPPtnvz4RNz0QtOYBmlTA6FaEZ1BO0urWyw9m6OiGQPNpwEzBjQR1UB2Hdkaws4QrWJqNWEITMcz+skTPz7jXMd+c0uLYms/YrLHjCfS2zek83sUX4Az5H0Hm3Zu/b5p6K/kKKUMf/M5w+ix2w0fPnzimw9HPv74gRQU43DiePwkKdmPTwIurUXbBtduqJrMGoT1oA3eB371izeYccOhi2yM4fEhMYxlnlaFAUWLO570ffFrT74iS5GNJMHAMm3J5kEpcTMQOUyQhAlg7bZW61eD8GumtKoo+jnHzwarWmmatqfrtrx79477+zu6vqOxDc442q5lu9syhQF9FJ8156xQJvQbNtse5yynx4+cT0/85euv+cufvubh8ZHxfKbZ7NDGlkZTs09qBVw1cEaIaVPJPS5pEhOaVNTTlAbMMUm6yMnMs5ktmlZnDUQz37OKS00OkNfjdl76yiAt/5x1bLdCydV3Da6xOKvxRmO1KqbXEnxDMY/GyHg+EdTIMURCyvg8gYZu2wtgRBYuiWYMDMcz5+NJMjityM9Tkh1WSBFnxB9ls+3ZH3b0m46mtUxDMR8nWSS0lYlnip4QPNN4FrN0TChlsDaSUcQsGtVY2gOESslPiZHEoFLRsGk2zYa3N/dsmpLJpwBnikP2MpOVBadqjopNZFZCFvNt221ROeF8uUpBSMIdO/iJKQahmlodVQutlS7+m+XZ8yJZH63m3X1WmlAW0hrrFaLwh4YodY81WCvVqP7imF4m71ru6sOjCnBd07VUs3GMqaxLLzWvVPkq51ZtrYAZ5r+pC36CpJdc0tcpaCv4SokZiPxLhyr/rf2XSvxBDSAtIEA2N6pmuKgLUtl8GKVnYnxrWzFROVdMVQ3WNuwOd3Tdhjfv3tH1G25v7mjbju1uT9v1bLc7mqYRralz4j6y5s2lbH5qoWbkopb3hXPp6sgX7fRXHTNWype3zRcQ6uVluZqwL280u2Tk5ZxFkvPc3xdlL59qTaupddEZrhGgAK+5aV6B8DOIXT1jrUkUs7y08SwjNWK7CtbKZeKiHV7pg2vA9K8vUxU2L5uKVYOzaEvhUn2+HDM8zLxgHaigf2npV4CnelmCyxJe99P1cSkvr7fAqmfX/Jfz15fnqXVp8uW51/L9Uzrg5dtV/WdZKPWeJ4982bYr0H4NWPOqzPO+oQKdi2vrk9aa/FVbruozawtLdroUk/iuBiBA9BMxjKQwonDoxpG7BtW1pGEiFed9hQQxK5RYrZXCZoWLYIcgPO6DR3mxXsp5BoxBWSum8daiswZjyTkQpwmbFcpNMmkOkuY8G0Pe9jCOEDw5phedoy8ashwGmlYUV/ubHTEnbt/ck3Lmw3ffksmMo1BSWWuLVS2RUyx0UxqFKd2WCd4zjiOn45Hnx0esmtBZyBaNSoXmUM3AcabtQ6FyKvdbuf+s3EbqZquufyIjGvQFid6yyasL8Vpi/or5+GeDVdc0fPb+F9ze3fHv/8P/wM29aECtdbRNI1pB60hG8/j8zP2bO+7ub3n/xWfcvb3n+6//wA9/+h3/6f/4j/zx9/+Nf/zt7/n06ZGtdXS2odvu2Oy2gCcGGEahldj5EW8059ORFAOtNfjTkfOn7xlOA2NUBNVAu0MZgyYJn2qITOcTSms2O8nn3bUtVivCqUelxPPTIz5Msu5mxcfHRwDe397QNh2nKTH5iNWetmnotzvaRgD6brfl/efv2N8c6DdtQQcjXWtxes/Hj4Fh9Hgv2Rp0COQY+PDDR06j5+NpEML7PGGc5fO/+QWukVS0wQeOj0+cjke+/frPhMETxjBzb2ZqpLb4Iu52O97ev+GLL97x+Zdv2O8anM2E5Al+IidRt3dlEHw4PXA8PfP9D18TYsC6LcY1dFlAXqKYdFMkefGxnMbA48czn9LId9Fzs22522/5/P7X/E9//79wfHpmOJ5wTYNxDte0uBLtqijO8TGTSnQ82oERUB+z8JEapbk/3DGU3bIPnmE8cx4HHo7PfP/4iYcwMqRwIZtaK7RV9K3DOUlSIVlZlPCgRo9SURJDaI2zDp0F/KSsSWHWdQj4ixLM5v2SjrSOPAlWK+elTNMITVvNAKN1Se0ZwgJIgCmNKK3E4V4JT+oMCDKoJNpiYfYqgLTi+9WKVNOiEnMBqRKtn9MlmJEPefk7vz4vKIr+Rkk2KdGAr+GLlCmHiC8piyUVooDItu0xxrHbbnCumcHn3f1b2rbjcHsnwU6d/L6/ucU1zcyBKrRs4h4AeokiNnqZ6Uq/UDOOJUk9m5G/q6Y7V1BWd+vV3Wpe+S43Oel6Zf+po06yc6aupTEvgeoLpFS4nFeWgALu5KssrjJwISszMs5Sqazz7LakQMyXpfwqU/w/XxR41ojUdeTFWbMJd9F9ztdnVpHuVSOa5+9yUgvLgBRq9fQsZc6z3Yolx1IBSJc4fN4oQdWwKapquVqBhCkZFgL9NQBYmRTXHLP146xFzwv20lI6nYrV6Qr4zzro8p/KFUymshmuADwzc7zOGshVV6z/rkzPq4xUUt16nV5wflLrC1/cklRgXg1izQuYLb1FBWmvbVQuEKhiDshU65/rM/MiSwuIl3lnviDLmlGjxWf3q7IZE89ZucnauyTO7VB9WpnvlVImBfF5H/3EeRoZTyPRB0Yvmvzz0ZOOjs35I7k9oPbv4f6G9MV7CaQ6DqgU0TngsyIWcGY0tFNkg8c9nNEpoWJxXTMOZQxWO5SxtLYjtRb9Zsc4esYjcDoz/PgjaRow6QPpZFFPD9jtDjsNsGnA3yIUAuuO++lDA5vO0LeGfvOG+7c7jjHy7Tff8/HhAfvpgRwlmY9re/w0cn5+JEXPePZiWW421NliHEeC9/zz7/7A6eEDX73fcrdvUUnoBYXm1GDMRoKzdHX7EgnKsUqSSJPWaZmWE+U/NYNWEaks3KvFMXbOWpfzrGARDMOyof4Zx88Gq9ZYbm5u2O8PNG1L0zistbjG0rSNgJuQONzecH96y83tgf3NDqUyw/GJ7775M99+/Sf+9Kc/8/U333E8DcQEbdvTdx2uabDOziAgJaEBEn40icqzJQOWBNHoOduEsgGMISstgl5NzXWgFBqhWd2t1OwbOJt1yISiRQwFCIpGCJzN4q+KXC8AvWWz2YiJ2dZAADF1k1UJ+Fi0t7pQTJyPJ46nMw9PJ8bgGZPHOMvmsKNpO4x1RB94enjkfDxxfjqSgtSndvIawCitJbhtt6VrG6xRUCgl/DThx1Gof7SwHmSVOZ+eOZ0eOZ/F3O2yxWQw3qO0EWqLDJUgeJ7wUxYhx9Loht71tE1P61omMzApVWSipes3oLRw3aUAcaT6MIL0sSp9nAovbkqxaPQUxhjJtJQzPkZGP+FjmLMzXQzw4p/snBOtOfpqdi57QVVTZbpiQhXzfyhuEGYOItCznMh1ZQHOuQRBrHeFBUDkfPGaVcYrAKJgAVaUjiyrw6LNXzSrZOac3S/G8+oRM6555Ryuvl9tkOfgCq2EmN8Y0UqrIsMZqDnCK+2Ts7ZYKFqMc/T9Dtc0bDeiET3sb2nbjpvbO5qmZXc4CFNI02GdY7PdY5yj7boyfl1ZpGrgSqU6UtfVEA1MFnC18EFeERupdWPWj+uGyFcfr1ttAWwry/NlV15clefx+BL7XnVSAXVzmeZI5Zd3vYAm+QILzilOX2qk1lpCZtPuNVBRLJHxi2a1aDFXJvilGrIyZbnprKWctZUrfHZRztJPqxFz1XKl5BUAzUhpda+8gMu0gtPz1dcPvXhGkYX1cJ2h3PL8zIIVc17Ge9XrLjK2BtxXz1m1w8uy/PRqrNSlZnfdZzUGbbmDulRYq5e/X5SpgowXLgDrU+p5av5qAaq1MRRrje/F7ebPi3UAlmZf02xdnr+qxzwelnlxjfmrm1S1rkwpM6VMyOLaoUKCEMhhIjcRjCK3DRx25OcjedPANJImMDNSKuNy8iWLqARdkwsYa2ScmskDGT0a2cgnyWDpjJixE8LLHWJEZTBZkfxEnkahzQpB3HhWG4HXNw9Lg+rSLc5ILND93R4/jexvDkTveShnWuPINkvCoyhue+Qk7aANaCNsPDkxjhOn80hMm2KpknronEh5GaPz3KFL+lRtRT6K0mmZF/K6yEs/qzq+Vs5E9fer68rq8y81xsXxs8Fq17X83W9+Q9dvJGd807DZ9LRdy2bbEzY92+2Ww92OX/z6F2id0Trxp9/+f/zTH/+Z//0//kd++4//yB8+fOThPHDX7dhub/niF1+y323Z7TuMtWRqKkd5H4azRKS7Bp0TvmshZ7p+R1aOMSgmpUjFiTjHhM658Co22LZFKYjBo8glYlgmia4xGG0ZxqnQOEkQ0sMwyQixFqs1GyPAWPwwNNt+z+Fwx9t37yRfcdtSoxajikSdcG1L4yPj2RO8J48jaRr58bvv+PTpkT9995HjMHKOI9oZjsNA03U0riV6z9MPH/DjxPB8wlrLZrMtXS+clSEllFY0xvL29oa//eWX3G17TAyEIXKeFM8PnxiOA30vAOHoj0xx4i/f/oHj8YGHpwdyhm4HtunB9hKsggiXNQqIc9SmStDphjeu4+3+ns/vPuPQ7THFBGy0YdPvICvaTvIZPz19YBrPPD98XyIZK69gwGSFmzzBTkzjiWbqyHFEaYNzLT4mppgYvOc4Dgx+En/aKw1Z27TsivnYWkvVnsQYZnOq1pq+K5aAdoNCieY0RYbzgNaatnFkEs45kZlZg7ukEs6FUcEUv0mS0KuJGSaSoi8APM9BVOLiUFKLGor2lgWUQjHpFiCboRILVI1pTdG7dh+6GvuvffXiUCya1MaJn5L4KimsEcCYtZL0t1lhbYN1Hbvtju1mx+3tHfvdntvbWxnvt3d0Xc9mt8M6AaVGG7RzwuFnJI2qLg/SRjZ2NYVpBXpzJvd5AV2jForsL/6LquzoJYintov8PYOTaiZem4vXjVVRwgusU4FqSb97tRBDhYXM56378uIRVTZUiYqv2r+6+M88qmXTohJVB1VDdhft2RJAozJkXd0A1GUV6sIwm+PqBqn8nReNoVqlxlSz1o+isS3toJb2U2XzpOt5JUW1LtyPM0NBOQ8T57aWxxRFQi78nxc+rEoWuyL7SuUZVOfaRiiySvM1MhbU3DZcfLrAQVUHJK4MWgqQlciP1EVuenF17SalV4Ajo2oZSrBn9RuukG/ekFyY9Wv/1TpLqTSVgSBfIsGiWZ0z0lXO2uKLG2f3izWYXtpANOaqNuvlUQDEsp2oX9Zz6+DIBYDIDarRol5bNwTiTrds1lUGTOWFzvOaUq1KqQaYZmm7nPIsC7P2W1VzvaRL3/RbwnnkU8gQEmelcRmsT5jJk8YnUtOTjYLbHcpZlM0k/0z+8RF+HNABVCjPUYkwPOJRhJDEN7ZohG3nhTozJIwx6HOD2jTorcWlzEYpkjZELD4lziHidcabLDRR5yPqfILhjEkBY0piEwR0XYYIvzzqPL1pLP/m159xu2v5/e9+hXWGf/7tP5BCxFmhwWw3W6bxzOn5k7j3nY7CSd10pCiBZOdh4vnoQDe0/R7UuVB1RmLKaEKZK8RX2ygjGwTrpH/iIBuD6ma5sm7W2UWCs+w87+Sk5LwyR8l6ViVWYkqMMa8I5+vHzwarStUgC4s2BmstXdfQtI7G2TnKHgIhKk5Pj5yePvGnP/yBr3/3O7757nt+fHwkJmhcK1rafsNuv6PvW4x1i7+jUsKZFrWYjsVOX3xVPOQsgTtWi6N0yZalYiTHSJ2eqy9FKgNJV/U0FRCIRm+aJqZpou7iQwmkEaCwaMSMlrSlbd/TdC22BJvMvhsUmqCUZjOyH4XDNY2SWWOcfHlNeO+FpQALypKzZjidCZNnPJ0LJZcXuikzSHBOCcRIZDrr6LuOXd+zbRssihwCIWQCmdPxzPn5TIwKbS0jE1McOZ8HxskXBbQShoHCKadK9isxB9gykcgCY5SmNRbdNGybLdvugLMNZAEf1li6tpNzbcSHyDSdihlUzSTz5KpZFQ1wDB4/jfhpIIwD0Qnpcs5Z+GCj+OamBeFdyGbTtPT9TkzyxsyR+tNU+r4A1lQ0uzEEKPWOKRbaKYXKorWPlYe2cqciE2gNDqurr5ikk/D9xlq+i1EzT7wpywKedNEgzECAeU2UAJ8LY6zIKcxuA1AX3NU5f8UY1gpaZ4osmwKQJN2ea5yMbecwxmFdS9tu6LqtgNXtjv3+hu1mw+5woOvE17Rp2hKZb7HGoZQuafwUWlsZG6r6mdaFrgAulRc/SMrftd3mkbxqqFWbCq5dNeDqTGAGDK9mSLlquMsI/HJdBaSvXFqvudCiv3bMKtlSsotAllzwQZnIWXwjs6rcMkvQ1/yEcm4NyFlgQ541HBdakrVmq/7IckIFWKqeXNFhNd+hFlaAy+Zeqnml0V5wU63jut5qZka62CvMbfP64lXbpv41+4b/C5pDdXHF+sNLeZJ7sRAbqPUzc+mOFZhfPffilnNvvT461/WoG7RZM1WPVb2usaPgQ7X6AS4/1bLXcfdTLZpn6+P1GeuNs/x9XdHrW71S17rRut7E5by4LdW58BWhUnM9RVhsYSLprKHNSQh0NCSfSKNnOp7BDbjkpc5NQ950omEdJjiehSjfS2ZGsrgg+AwqlgC86rqgFMlEbFYkY9A5iIbh8QRKicbVB4pT25y2WrqoIP6iCV7TQOq8tOXFGGVNNbdqahROG7rGcXN74PHTTrJolvVGFb5VbSxN24sbVUYUDjHIXKw03nuGcUSZhmazx7WdrFePJ6YplvmmcOxdzAu1y1d9vp6I6nwzyxtUeqsldUy5zxwVLDWv2UXVT0jn9fFXgVVrZYFr2pZ+03NzdxABasysYfj4w8DTp4Hf/+N/5bf/z3/h//2v/8Dvfvd7/vLpEw/nM+9v3/F2u+Pv/+5X3N0e6ApPY/AyOQv4y0zTmZwiISSsLT58MTFNZ9ECNQqbNU3X0ISIaz1x8qQ0oZTsSoxWaKPwIRB9ojUKTcnKkxXT5BmHkcfHR4bJQ5QItmkaWRwwmMFq6zq22x13796wu9ljW1f84/KctnEaRvw4cjo+8/zwwHQ6EcaJMD0TpoHn48DzeeI8joze47Ydbbeh396jlOLH7/+IH84MD0/FdzIBI+PxSEwRH4IQFufEbrPll+8+44u7e95st7QZwnEghIkQAt9/9wOPj0fx0dSac37G54nH0yMhBTCSjSImDwHG8QgoQppKOteNtPsUIUKnW0zb43Y73hw+493NL9g0e3LKAlS7Fmud8J5OEj0fwggoPmKIMRNDnf0iOde2huPTR5TOPD/8SO425N2tpNgbR4ZpkLSwwaNivJr8FLvtgXfvvsAW3jlfmBiOx5NQd4SJTMJPE1GLphtUyT4V8X4k5cQpBuoCE2NkCl60omXjEkOlPxOfHqMkaj+EynkqA3i9KKbCq0lIxblfyh6KRm12Q5nB6FI3yR4lccSpnrTcen79LHcoJawpjTPc32wxxmBtQ8wwRLC2od9s6fuew+GGw80N796+43C45fb2ns1my6bfSsCUq3RTepnIXl2rSm1ziQXPCqUL+FGmANbEK2E9i79kRQ0zEHtpbl+33eXEWhbE6jN6DWpWtv1azrz+aWWOnMFM1bRWDtS8vF+4HFDW2HmnURFkoamqwEwjGjS18uosWjt0vWcJFpyLOzvjUtcEtdrmqMJXWT1FF1PsImGqrqdUT89yh9oNuizmMxBWZVNRA1IrkK1Ns7S5lL0u20XvpyIXy3PRMl3BvVWluGh7RfX2hMrZmq9NzOnyXtdiWX0yKRsiLY1PLl1Us+lVxQMZsk4XrFy1PZU2c3suHQkzy8M8KnOpQh3sCnXh0KBnNhd0Wg1oNdM2KUpwZkoFS5h5P5HK71z1jCpjTM8sBldglALKV5vInCsLQAG5LHPLnNK5dknR9Es5Ft7o62MeHymXmFdVlESLf1PdFtY5QBV5FjpW8ZtUKtM0hk3X8Nmuo/WaNnlUSgzHwPTxzPTn7+mTw749SXKZvoP7G0hfgjaCxdIjnI9kL5awMSVxJ1i5DioUbhzRKII5ScB0Y9FtgyaBMRgkeVAgl/WgWgoU3hhwDbppUH2H1QYbIipkVIBowOlFw1rlupBbzu1cx4cBNm3Lr379FSkEmq4jxsA0DBLYqluMa9m1HdGL4ud8euZ8esJYRzaG8+mZGEZMv+Pw2d+w2ziMhq9/9088Pz5yPgexJCogmdrr8l7pNurmAQHfqkwkax9l6b+aRYsS31G41Y0EceVieXTWYZ17IZs/dfx1YNWJn6ouC7gxuqQzlAKllBiHieeHEx9+fOCbb37gh4+f+HQ8kjP0TcPtzZ67m1v6vqWxElihtUJR7KPFJBCCLNGpBpogQp1SKs/TMg0q8Rup2ZhiSjIBG7V2V2KdZiGV4S27k1A0hyVQY95pIqnByrRmrWOzkbStxomKPMYotFo1k0Sui1giTBPj+YwfJ5L3siBbR7s7sFGOTYjY4Nnf7mn6nu2uLwNYtL3BT8WcDFAYBVIkZdktta5hv9nw5u6G/aantQZSxI+R0+mZcRx4eHzk6elM120wxjLpTECRlQRaGSta4VrPlBJZKSZlQFtys4GYUHESLjptMWhsBpNBpUz0nnE4E72Yv8kr0xPMmseUJE1cJaDNKQmtT4liDH4iTBN+HEqkpWh0K7dsiHFOhXqNisQHp1IbGWI0JJ1kl2mSRPsnIeSftZuomZxf3AVqxL+sWrH4SysFlOxn1WwtO+UahV9IaQqSyNevUsaUAJWpCa2qGUzlpa3mY/WMVzBgPeXVz9IessO1VkzxqrA09G1D21ju7g44a2nbnqw0UdmSnnQnvMG7PdvtjpvbW7abHdvdgbbtsG0rPuI1hemML4pOULGMnVKyJWK9THx5WeDUcuIKJFaf1NVWccXVeQWJ/n/m3rvZcuTI8vyFAnDlU5lZmSVYRbKVzaytzff/IrszLdlNdsl88gqIEPuHRwRwXyani2az1g0y674rAARCHvc4frxmVxEHzOvt/jJrzOX8cxVZPDtLWsbl1v5rT+vsNVpCkk8vnb+tXMS0dF7IdfKiXMAdS9B7sS39yS0+ORZw/7LGPrnI5fcqI8ICMXNJWYJS6ndz+Zdcx6ItPd9joYKg1OWZS4sOOTldTNivHmpeL+e+M39cLlFB2GV9LBHtfM/XoLt4vtLyZ9W1WPpgmTvkM/l4huyf9P8cSDXX9VzypYGlFnVdn2xRFzXDW6JWhFIp2zqLms2YWDEnMnglv7x49rm9l2Ox/CBl47Bi/PmEudkSn1z80gv7uZqHC0d8abcK5nN9ViNQfuicIzSWaDQuSIyBxDQk4hQIxxF9GghjD06hdENyDWx3pKueeJ6Ix5H4cib6nFmvrtlyD53mttAksdmSwgSF9h5zHsAYojJMMTL4gE4JYsIoR9QWvVqj725Rd7fouxvSdk10OcUzqgqZFXhf9u6OfY+vyWbA5nbRMXLqR/rDkWkYsLbBGIenp86xWlK1a2UwxkoilryupSDAPATN88uB+4d7truvWO823Lz7gm694f7jM+M44aOm8JhTCrUdytxUvM5iXIs6jsCmIpM2GztlXi5tKjKNmlh32pZBnf/x8eulq7RmtVrLooV4LZ0zWRRcFt9hmHi+P/LDH37hX/7xe/7n//sH/vXnn/np6Ynb7Y7r7Zbf/uZL3r19S6MSRpE1Ew22dZAAT2bGAAAgAElEQVSgPxwkJ3vvcc7kfO25qhJMIZDQqBJJrg0+iZB/kXtKRjw/Lop1qlLOV6u0ZDZKIlvkgyf4kTJhaC3boiEDLqstYg5aum7L7dt3bPYbXCOamlM/YBsnWaqiqpIahMh4PHN8lCi9GCPdWjQjr7/a0k6RsN/jg+fLD29ouxa36uhPJ75XiRg95150ViuPLCUigYSnazr23Yb3d3f81bdfcbVp2XQNw/nI6Xjml59/5Pn5ie/vD7ycR/a7tzTtClZGJDVMQqtE00pWJeGVKGL0eG04mY7g1uy3b9CTR8cD1k043WKUwYWInjxMI8PxwEEXV/4cKJNSJKTIOA70/VlS2gaPDuKhiUwQA3HSeBUZz2d66zgen4RTvBfP6jiNDNPIOI2S9pbPgTOhgjjrsMYIcFZJNFpJqEkWwmmQtjaZN6mSgOkpeJZbujEKPWCahJeTWyBnjRIZL5XkC5l05hLFnC4qcYmNYkg11zXzi0wAWuFsXulzcF+In4Pll8ef+94Yoaxs9xucbXCtZF67ublh1XW8ubsVnu/uCte0rNeb+mqdk0A/YzGukclPGTCqGjXLcJmaCmWhB0kFXPJ9SgqdDQSVPaMq5hTGaWZvSZ3lxb5U8AVKKQ2ef1+BBBdAc476/xUTYVkXYe4DdYuyANRYL3UJZhcAdrm1ubh4ypmLJHsReYIm5yKSayulhI6YUq1F+V+BGWKYf/pcS/AzHwX8VI/FZ9CuWvyubPfPAVGqetTmZerS+1XKWRbaeqtSnEKZyfJp805VMc7U/PucZUlRtmfVp0130QVKY1waLyU4ydSvRYNXfwJtl/WSx2MBjREBmKp8PoM0oWtIgpqZ/5qNWOUvfq8yckxVYLfcex4nWpUWTvW/CY3OfaWY5hIcDCST6RYq/1IApdYFT8xWkFZznhnUzDVdHjPX+xVOFQwiOvoLIDw3o8q76EuroPxOzW/rCan+XbxwUemqeqLz9nDJHFYcPoXClUJEpchqtUKPI8oKWLVKgq2OXuFPgfHnI7E7sDs9YbuI0g10HanbE01HXG0I5wn1fEBPAwyiNqAW/SCPNEz2MscYMUoRvLScezqA0URj6YHnGNEkVilhtKFxLfbujuZv/hr13TfYv/otbHbE9RplBTeEXOdLL2qMiZ8fHjmfzxzOvXgeYyPUxTAwDiO/fH/P4eMjbbshTIHxeJCuFQPKOlyzwuRsicY1KOM4H57oh5ccq6P505/+BDry9XffcvPuS3Y3d/hx4J//1z9weH7h5aWXoPZxzB7RUI0f6VdKnDdZh1h0VjN4VdLxVL5XzFsbxRDXWtpexlDMADag1OvB/vnj1ycFQColRrFIUp04ZaAEH5iGiWHwDENA6YZue037fI/ThlZrOq3QIYCfUFZnnqvOOe3zxGJtFiNvJOAqZyXSpRKMJSmYpsAweI7Hgb4fJHOWDxIIk2AiYb3HeFPBbhlBIUnk/xQSk08S+BMjq7ZBobJEj8bZBm0srl2z2W7p1h1N0wiwC5FhkGxUJoMk5yxj3zONnqHvOZ9OIk6vFSEGUlBgGrSytNsNNkW67Zq2bXCuIeVsFaOT7WxZ5CUrRYg+q7wadt2K92/ecHu1Y7NqcVaoEyEGRu8Zpol+HJiiJ5Cw6zXd5gqzdWASh+efiHHMigXziEkxorSl6TY03QbdblBqJOkzyjhs0yF4XpFiYBoHhqHn5Bqsthht5fvsdfbBMw4949AL77iKfpeeo+oWmHgqZas9+YDKOZ5Dtgpj9BAjlk8leKZppO/P8r01TEFS7cW0zKJUJIRmiJdCrJGci16eua2penDqGYsxVTyrxUouc/Mc1PO5ATRb0wv/CTpJMGH5YOlR/Y8AK5C3YGC1WuMax34vih37/TWucbh2hbWO/X5H4xqu9nucdazWG4x1YoBai+u6KryvdEm7uAAgtdXywrso3Mx7SwuQh4CQCoLk2VTZVmJewyucyJVXeK1lnZPfzecVkCUfv6qh9GmdpT/35aJxqye1AFKKV2cJvsvnMP908cyfNNZyQX/9+awkoZbzafXYXQKT+NkLpcV7dfFn+X5mAJfv8vulzZE78GVVXvT+xd3Kf2cPiq4mWy5p2VpWyzNfgRkWY1mVkl4+2+VYms+tHvu0LOmlh3Dpn3/1xfKl9EwBhnnPX5euvKwGKLpKcx1muY7iFa6qWaVP5b6hWIJwdeF9XIJjFtSTxHJcLZ/zspNVDmR9VFW3psvnr7FqoYGULqMuL1BfX1+7lEzlvlm55SUByaK+5/uqRfCUXKw2RyZxFnCfKxmIOfW4BHpqo1mtOtQ4cLKOME2M3jPGxESW10uItyCeIVhiXKF0Am1QrUXvNrBdkzYr4jkQdcgBQ7PRNQcryt+eQsHKEmde4hKCioxKM9oWQ8LEiFutMbc36Ls7ePcWdb1HdQ26cWinUXb2Ji5myBo7k/yBNB3pjy+Mg2d8PBNHj+pPjOPIj/cvPD6+MJyemYYzMQUpbdCZMjiCkfgXlOyc2vIvS3UNfc/L8wsfP96z3e252m9pV2vevn/P7uqazfOJYZh4ur+X3d3hVMfa3Efyuk2aE2pkJ5XkGFCUJBrLVq29J5Xsj4EYFa+n7z93/AXpVhPeT2hjxCOZeWBlu2waA+fjwOk0cDxN2G7H3ftveHx+4PDwka01bIxCjwPT8UCz3aByDnRjLSanIbNNgzKWLkmO9BgDKQaJpLYG23QEP3E+9bwcztzfP3EevGR2GoWvgQ2ixWhlux6jc5ozCf4I2Zt2nhLDlOgnSTyw2jbC7cxckLZd03Qr9re3rNZrdtc7rLWAwnvP8XiCpGhMR7Nr2O02HJ5fGM49h5cDz49PbHcdbefwfhK6wSpn8nE3oGFzvaNxhtY4DLBZrwnDiDWOqCK21oFHK41ThjdXN/zd777j3e2e692KTOFm8oHTMHLoew79mSl6koH13S1Xt+/pbrYok+j/1xPjecxyRBqQ7YJx9Cg0290dbrXF7u5I5yP+8IJqWrrVlqLEHLyn748oo/Ek1m5N61oJzrGGcfJZjPiF4+FJVACSJlXiWBJrTDc5mEoRA0yjR48TTD3TNEqQmZ8IfkRFT4NkIFn0TPr+xNPTPUO3xjmJXiRl+kEOHAthqtv9JajAT5N4rHMUsDHChYtpzia0HHFLXc4UJYitbNdrNYOqy+Xl8oifGZihlOFz4+5XjE2bI/m/eHfLbr/nN9/9NdvdlWicNm32lEomL61NpQcYYysNRHh4Yg7lD3MwnHiH9NKKTvCpyVDmgiWDVhb2hLDsJFBHjFL1CXhYnrMAwktgVRBEPsolPp0ML8HVJ7NhDq4oW/jLC8y/z2VfgtCKRctSs/TGiwf5k6MAkboYz6BEpcvX8kxJydaunKZyOTM7cVlv1f9Z+JILhHAxRDIorlqespiU4pZLxkxzSYmZM0xB5fPlopqxVfGG6QyqY27vErGf1BKwqXrvsoWu585AVJLghTjX7yWyLJa1eIFJqvYj6VulUJeEjXnXZzaAKhezQpN8myi62EQBfJd50RImSva2pGe2aO2gqjTFXG7RuI4oFWSHLy/uJbI/VcAW62mF4hZLWuyiN5vLUbzypYV0BcnliXTm1M9gsbRTOYqHs2JLJedVEFWMiQwka30uuhDkrqGUcBQvSpkuflecFIUuJIBGAHyVEqsWoKQ6NUZAV8wzyP56j1OJj+0KP3qO05nRR8by5AmIE2p6AQPJO5IRx5NeN6hVC3fXxPsn4skTeo+K4n8PSfpu6WFR5fgW0WpgSqJ40U6eFBJeKUZn6bstJiVS8MT9LfabbzHffUf6/W9hv0FtVpjOYRuzyNZUdkoFKAcvO7xp+kgaHjnef+TwdOTf/p9/Ynw5kh6fmCbPx37iPEVeXiSCP2RMoJPsMg+ZCuBogUTTWGLjIDRYazBGcToc+AX453/6F4bJ8z/+x//N/vqGq5s7SPD49MLxeOLv/+ffcz4cOH8cSSFH/itkza4eeQmOLTKiKbfvTGmqJy3GY4JM8fPBy1j9lWj1L6MBbDZ0qzVXN1estxvp2JFZokdL9H7fDxwPzzw//UJjRGR/7TTOakyWK2hsQ9O0OOeyOLgDxFvlfWAcvXiLFSijaFfi1bSuYRonnp+eOQ+emGCcPKfjqQLbkey+t5JVwrUNVpGzXs0R4iKwXhQIEoP3EnjSrnBNx82bN6IZut3U+0vaToM1DW3T0a3WbPZbtFb0fc/peOTl8AIaVts1Sgso6o8nyT2/TUTXEozCWE2JAFdKtEW71YqxH2naRjiTucmNccL53ax5e3vD3c2ezabDaPFqh2nkfD5xOB4ZYyQaizKSNu58eESh6b2UaxpG2f7QJuuNRlI2TTWJ1miMSsSxJ42DcFFj9mQo0ScNEYZpRA0j6AGrcgS51ihjq8dSa4uzLa7xaO0zL1cSO5b7ayVC/ihF9J40jsTTkfF8YhjPBD+hk2K72rHb33G12V/0zRA83o/0fWIcNcXLFb2vQP+zIKpyouSzWWR//jwVvJouMU/xpi69IK9f/xxg/dzxeriqz3x28SUI39torvZ7NusV77/8mt3+ipu7txIstd1hrZMdAq2r4kYR3v/E5VJn/CxpsxDRXGbQko5Qa2Dxfb7IAgHWs2Je9Er0f5JJq2wNzuA3e7giSKBR0V0tl1ZceAo/U0npVWOkT76gArDiJS2fpVcXiCwm0zSDoFS2KDOwqnz1VwVS2ZuWWRC1TusUXvG6qs8OBUAmihC+SovmugDF6jOd7ZLfOzu7CpCt8G32cJEDqIpHNF83LS/AjINrpHoFL/KHrguTgLqYRcRJWadaleecPS9l+7oEYy1g+/xawVguXbqshrIwvgapy/efuepFPyqLbTmjODVL4JH4R9PFzvbrQf45L78qNb3obxdbn2WOqUcZW8WCvfSNz0AwLe6Zqm6yjKY5Zari8xnY61b9xZWXPTDV+qgPW2kwzG34ySMXo3Xm3pcKnnVkF89T9YYXBcpzhHRXjTYK1zh819Hsr/DAeDowkUjREBT4KbEaI3HyKDug/En6gHKgDBoDqwaut6SHI+nQk3xWu6kr7UWzyFyUx684MnIRG4dar2je3ooDQGvs2ze4r95h765Rq47kHElpUpK4GpuE+qFSAAIpTJACxICKHo3HqJjjDCwYTdBwGo+iHBSEYqhDIEVw2eCRQMyI96JoJENFKIRt29IacFbhjEgoBj/x73/6gWM/0riG29tb7t6+oW1brLVYZyVBU4r0j5YYEzrTlYx1c1ullPVX8xyuSi2m2kuXc5DKQDW7wEVH/3Md6M8cvxqsGmvZXV2x2e14++Edm+2mLvaFnqStxYfA8Xjm6f4XfvnxX9k7zZsv3lRNy0IObtuOLicD0MbQNh2FtzJNE8fzIPp3OqGdYbvbVUmd48uBn3/6SFSGaDqGceTp+QlrNNZoieRWStK2psBWK5xWks2JRAyilxnRRIxIQQCnccTahuvrWzbbLR+++gbjLFiFcyITVTisjWtZrzbs9ntu3t5yeH7m+PTI4/MTHx/uUUazv72if3lmOp95uP/IqR8INxN0K9rthrZtJIApiZqAdY7tbkv0ga5b4adJItBzVpPdds83X37J1x9u+fDhViIKFUz9SH964fn5ifuHJ4YUiK5BhwGrAof7Hzg/PqHWDRhFjCPGKBHItwZCJCiR7jAk1lbAezgdiUNPmnIQWgmEU8ITnoaRyJmQEG6ka0lao0wj3mvvMbahbdfEIFqlw5i5uConXdAi1E/edg7jKBGVz4Zzf+bcv+B9wCTF3faW373/mjfX7y76ZvAT03CmPx8vvJ8lwGC5tSvjJoPZClZlVQ4pSiCWXw6e15tuy28Wf6dPh9yvG4L/8bVfHxlv4FpJs/vFh/fc3t7xm+9+z/7qms3uGts0WNfmTC1C1dclalwrSrTtAi1RtEuTikhWpAiL15Ri9owvIMDrhaqu8mVBlcV+yUUtRm4FL0qjzAxyUwZNSumcMWVegpdr2n9okC+81alMlCwgdpr7QUEn8rIAq9WruTROioxZmr3PMRFf5UMvAErAQo42zgoJukT8V4BUOIszqURlrmI5Ryk9A7C0BIrVxsilnhfeAkrldwWszoCmeFhVUpnbv2jyWu+1oPV6Uc3tL9yz/Cb/PmLmAubhp8s9KyhKMz4p106J2YOqFzAtLf7Nz1DxLlBV9Bd1v/i21t0lIH4FWPPn9W5x9sgqJDhTyjnXfTkKaFyWqwiuv9ZYFTfJwmCoE4haFCRWsJwuyjr3nXLfpfEhSW/AFINCFSNhUda6dZsfvewgsHxf9ECzB1ulyoIog68I2Iel5VCMuFdjtNB/dO4vlRKVJF2oUiU2PrdBylkBjcOgaLOcYXv3Foylv/8Fn2vcq8Shj6yGSBxG0Qh1Kq8HBkwDxsG2Qb27JX58QT2fcjIAqgLDpU8+C3mUOQJkHVQWVh36akf7zQdM2+FWW9o3N7S//xp9e4febMBZAjmeIymcShlwBYgjIZyIYcz6pQGjRowOWOMwNkBjCU7xML4QphFLhBgx04ROFlJH1BC0ZID0KZB0gBCE4mcM69WG1m5Y2YQzkeMYGMaJf/j7fyT90x+4/+WBm5tr/va//x3XNzd899032Mayv75Ca83jDz/l1NqTgPJmhfCJRddeRV/7+7KHzTQYqMZxugSsIYjP/P84DaBpGj58/SXWOfwwMFrD0E9Z3DtvBWmVJXEsISbO54FVMgQlpF9nLauuZdW1NM5gjaZpHNrYzE8VQDNNXlzy2tA1LY0xxP6IHzVT1Jyfn+jPJ7ANetVIWs7zibZtsLqtSQskr7ipk41OYrk3zuHbBoUhJkXEkLSiW29pmpb99TXrzZbt1ZamFc+qsUbSyqJRONquZbvb4pylPx55/viRjz/+SH88Zk+xEJNHVVQLJMK+cQ7dNLRa41QRClZEH4h+qhIgrmlksETJ3LXr1ry9ueHrD++4vd3gnEXFvB1/PvP8fODlkMnZzkiQmbHYFDBodAKrLcoappQytzQDRD8Sg8ekgI4eTi9St7rFKUV3fc3pBaaXhyz7RfWoj96Thp5+GHCuxfRnka6aJkKINE1DXK2yy1/hw0QEjE5oDTF5iaQMGu8V09ijNdipow2BddLotqHZXvHh3Qe++uZbrq6vL/pmCAKCi45rGTRGF56krJY+z7SS7CBhsu66z4OrGn3/yYfSkpDBOUvbibXrMv0koapM2mqzpmlb3r//kt1uz2q9yelLF0iC/FqA6SfeqHnJrhs3FYWoWndV73PGH4vfzkeZpOatvQwOokK29GZvnnCVxasS44KnuohfjnFhtecgyYqL5MNaqBmaLBb2RT2U7fxq+xegeeE5nRcm0tKzujB8kL5fBP8hL86v+FcLaEXxCNd6rAhzBvVlq7wA6bJVPsfNZCCbMsxR5VnKQxWgE6m7xzDX2YWM0bL1X226p7ncM9RlUc5P34t3xVA22FXmsKoc5FR613zXJT+Q+k4ymM0GVMr3uOhmr+q4XDcWA2BR4kuIJhdMatkP5ja4/JsS6zzXh1KoWLi65d7q4m6qSPsUvauUe47KJnJuV5IE5WpSJZeqDGwLJahQhj5NbjH/dzmsq+wUqtKSVB43r7DqBXCunjHSoj2W7TJ/WLvZq/rVupQ1X28Z0bUcY/maqZRViQMkFVC+MGqXpVWUoG7L7uaKRkO6v4ZzT3p+IaTAGBJjjkNRMddn8VISiWEAB6wt5moFpy3Je1KI1WmksjKAuvjfXJdoUEZjG4dZd5g3V+j1FnN9h9lvCNsV0UGcjmgcgZaowCnFJCmjUPGIij3RD6TocwIZAevGtmyv9+h24osvH9lsHP3hB/rTifPxQCCCkzV9ZRSubVnt7ziOI/fHAyBp3VEGpUX3umks+13HZuXYTZExJB6OI6NP6DDBNBC9xJf8w9//EyEEfv7pF4ZTz+HjPZrE1bqRTJGuQeZrK2X3SLBsTSldVAMQXKjzSCrUo+Wa9BcevxqstquWb3/3Ld57xnOPQtGuRY/T5S38wit1TUMIkdPhzEZZ1sayWsnCull1bNedJBiwWtI25u3JEAJ+mhinkZhEhH7dreisJR6fCQmGMXB6fOR8PKC7De1qyzhNHI9HlEp0rcU2ltV6jdXF4lfZSBWuU9s0Ih2kjOSGz9vQq+01q9WKq7tbEUC/uWK92XD37q2A8pTZd6mh6RrW+xXD+cTp5Zn7n37k3//5XwjZja5UIhiRDUpJi1yUSbSNSAA12uCUwqIlOt5PWf5JbMWma0EpJh9oXMPd9pr3797w3bdfsuoMbWPxg0TLH48nHh+eeXo58HQ8Y7cbrBWhYK0SatLoqHHGoZ1kaUIjgrwqicc5TOgUMX4kHZ7QpkHZNavNhjdvv+CRwMv3iSnTJ8STBGmamIKna3sJEgOsHRnHgRACTduitWbyon87TQOKhDXSoUMcSWi8B60T43DCqcRq7Gh9YIth0264vbvjy69+w2//6m+42TUXfbMEWJVt/DK5WJs9RdlrMQWZhEwrn1stnDTvxdMXP4nm/s85jIamUWy2Hdc3V6y7js16jcSdioyaMVYkpVZrrq5v8vhaY6xkjKoYbeHl/GTFoviQyl9pPkdpKNvwaTHhpOzdpAC4SzCTLv4o27oCKJOat1OVlmvosvrFVKOTBdBpilxP0dOURTfNmFtlnlABkPWhZs9YKUwFgPlF/sVFHcnvhHMZs+GS6nYnGVTPW5pyXsoJKMhg9fUknBSL3c1MYagrX5qBJnlezwt2VAsdw+LZrdxFuWh1jBWOWL5ZIgioKCLcurSV1KdWC+/V4vU1UBVQMtMzxEgokenzM4onT7QZlSr1nb30mcYRaz9cwmAQzdTZg6woAXlpwQddGiKXr5dfXta9qgbCopmzlJTcL9WLVU9vvnKmsedsUbkuc6UoFMkUkHwJjFWUXak5ZTX5/mKYzRnRIjrKeCqKICa3P2WOLW2xpJ8s7lWNy9J/CmhVqtS8jBn9GvzN1ypNqbLxWIF/mukxqbbBPPbqZ1q+0Wn+TK6r65vEZYrsaggonXmz4lH1IWb+TwG3pW6lL2ltaRrL9Ztb+tYxPr4lPT/D6UzwicEnBh8Zpoj2iS7le1iL96MEILmE2jWk2zUpeNLpTJw8esr8VZ/Bat4l0aWFc8VoBdooTNuitmvUF7dwfQPvv4bG4FdGpszxGRM7phSr/qpKkaQjJryg4hGCxMrEEPNuo8G6NVd371j7hE4vvDx3HI/f8/z8zPHfz4TkSU3Aas2+Vez2He8/fMFPT0+cpiN+GpmmUYKdcViraFrL9c2GN9dbfEiEkFD//sDLccSGCTX1xGmiP/X807/8gcPLgZ9//JkYIivrWLctm/YNrjHYpqVIlQY/4bOGagzTPItkB5yMGV13U8SFXTrF5Vzwa45fDVanYeDnP/4L3gtfYrO/Zn11AwiPoQRXNK3j6mbL3e01X9y9YdN4rI20XSvb/tZkcXInQFXL8iUR/Z4piJyEURqnNY1RGCLjWXgbz88HHp5eeHp+xvpIaMVrZ5uGkCKn/sR6K1mxynaD5Iy3FBe0eH8Nu90eZ1u6tkNrzfsPH9hst3z97dfs9ju+/u5bXNWWLdkWNEoZxqHn+eMvvDw88PDzTzzePzAMA8FPBC1UhuBF1H7wI65rUV1L0zVY5+hy5q+mXWOtZRxOjFPk+HKkP56I3qMTrG3H1WbLt19/4O52x6qzOAMpeoZ+4PBy4On5wP3TC4+HI8+nMy4l7OjYtIbWrHDrLVq3tKsNurFYa1A6iYpA8qQwEP1I8oEUPP3hAdus6fYdWieUjSgtMhYAKF0X4BADhEQ/9BhjZevf2CxVJZNU2XLSWuGsJigNyZNIVaKpqdOkZFNatR1NJwZE0zVsths2rYU4wkLuCKheUQ2ZqjB/kZIiBJl8Y16Nx1EiTbVWM40l/aVD5//woaDrGm6vt2zWHbc3W7pVx2a7wbkG1zSy4KFQStQiXLvGuoamaXL2N3m+shwUMJZSni4WHshKR1VlwV0uDszvU5IFpMpGpMufMYOc5WJavsm4oF696CRXvdUcPjFvY6vqCVJlktdz3yig9xIivK7LS/BaS1WBZ4Yl1bNK7QACM4rXdP49ReM3ey3LyhyDrx0whvnzekRIURH1nPMbyKEsS6i/qP+ML1NFBeVzqaeoEqhYQV65Tk1Dmu9z2aozMF3oDswANS3q6QIKva5iVdaj+TV/XJZ3MTYsywVKp3KhpYqMys+k670VqahDVRUr0nzfua7ggvtQgfKypAukmxbnvXquBTVbzkqpnpJIOaBsYSjk/qpq+1ANpGXxYNF/Fp8Ur3nKnnsV1QzUC1Bl/idjea4GKePMyC1c1ZmbkDmYalHiV5Uzj438Oz2nRgWRbkospKsqYpOW0tXeSRXMiTNZ2mnOuCe7DSqTVy+rYp4fSIVSoObkKareQgyenImyaRuIa67ev8dtNgwxYsYBfz6y2W5omg3WuHyPAGGQtcE4ogkkMxE3hjg16OuVJAQYJpSPqNOECoVDS92pK4+bk8pmfJ1IyqPUhLITSSfKqSTQaRDmdhjwwwtPpwfC8MLKnWnMBKkhJs3zwxPTNLHd3uCaNWYr48LohDOKzdUtyTiOw8T5eGToR1JSHPUA8ciq/5nen7FmIIaBlM7IiuohKVKAl+MzgZGuXWGt5eZuy+4qsVl1NI1BTUeS8lg/4mJgY42wI4JnHOH+8ZnN6FlttlVfv445Rd39qt59pdAloDoWQz/WXYJi0MhuzK87/gKw2vPTH/8gGaVcR4xw+8FniaUcrJSSgNXrHW9ub/jizR3EI8SetutYrQSsWqUyWBUZqJREUmGcJqYQCCnVXOXOaAyJsT/Rn07c//wTDy8nHl+eaGMirbb4GLBtQ4wTp+FMUomua8ViTYnGNVhjIUrjFarCfrtn1QY2ww5jDe8/fNqyzcwAACAASURBVMnuas+3v/89++s93/7+t5ASx6cXtNLYppOFU8PDTz/x47995Jfvv+f7P/yByQem4AlaBts4TUyTZxh6xmnErjY0jRNhdefoupbGNTTtGm0M5/OZaQqcXg70p3MGq5rOttxsd3z71Xu225Z150hJotyHYeDl5YXH5xcBq8czz31PEzyut3S3N6hmhV1vsK6jWYvHldahTcSpQPSJGEbCNKCmiahGUlQ0q8Bqf4fSCW0T6IjEv2uhNChIKmWx4cAw9JLBa5zQKnv2SJkXp6r0mDUajWYKOcithscXOonCaMO66XBtR7PZ5bS6mrYxkCbg0rNKhBRyCl41L6ApT5A+LO8DU5RgBGszFlt4Ef5TjlzmVef48sMttzd7vvnyC2zT0LSt0DWUeFUlXMVIzWrJgaKNgwuwWlIKl/S0cm5ZGRJlYZFjAWHlr1qBuRXztlhWzK74KV38Zr7S/Ne86Jfd+gLSdJqn//r7uu6bClalKDnzSbmxeiVx9Lk9zou3S7AKcwrdDAIqOig0gFj7Rf08vZpwCzgPog2qUuCTbLsgi0VexJce1ZIhaAnC5zqdm6O20XIvvPB+X221U3mw2RAonup6HwEgsX6YKnYq9fTaTz6DFOr5pYziUc19JnvYFPVLlnCr8DlTIcQqlQPtFuCPWLmwMV/zVRzSq46SS113Uz5juNQfpsv3n9F2nMdE3Q8gZjBmste68L1r0H8pm3p1l9I/Lt4vfp9SpQromJNsJCHJ1FDQ2h9i/b20la0Ar3Sp+TVVAKmLp1S93v8oz6guDEKtLmvxooeq0poxX1vNc0y+d/WoJSVb6hnE5HAHQizBTHP9iKJXKa98FasBVu+efyqV6FqHNgo+fMBtd/TBY88nwrNju13RNFuMSeS0lxBGlG7Q2pF0TzSeuNFEWtJVRwoBddYwBbSPqJEqcziPjTx2iCgVCQaSTkQmlJrQdiLqhC+2WER2KpMnpIgm8PjDP/Py8AM328S6A8w1MbX88V//jfOp57e//+/srlq2e9E/NypijWK7v0G5ltM0YZzj+fGB4APHOBLjgWb4mSF4rB2YfE/iBHi0aiFpYlQ8HyOH8czdLWyaDTe3GxrbCL9VKbQ/kuKAmUaaGNg4gydxOA+MIXD/GBl94OauFyqjcVA0ovNEXdq7vmbGc1Ih70CVOSjP3zkVLJ/0zc8fvxqsDn3Pv/zT36O04/1Xv2OcJsahRxtFlzqZsFG0XcP+esfdm1vev/+A7+8J4wu77YauayVzVeNEumCc8GmS7f3siZu8eONa1+CcQSnRyvTDwNj3nE9nTuee46nHrPasVlsmH9DqhTFrfwZfJIqY89GCEHpjQGfx3ru3G9Aal3Obf/c3v2O73/HF1x9oGklS4AfPeJxwbcPuZk1/OvHwwy98/PEnfvn+J06HI8ZaSSQQxQM9TBOnc08/TozDhA8R7Sc0ifH5UfL4mtvsVRa7LWULyHtPDAGdNOt2xVfv3nN3u+fmbkfjxPqdxkB/OvP88MzPP93z8eGZ++OJ0zjhQ8IFBUajbINqO0zXYl0jeprOgoOkPHEaCGGqW5khBFCRcTqjujVtt8Fox/h8ZjqdZStFNyKKjKgQFGUF76U/pDjUCRbAZgH+aRqJ0aONBmXE8yJCpWhlca7F2RatLQnNOE0Y17CyTqLIDIzDifMvf+KtfQ/X29o3I5nfFVIJMJdBktfK19IY8tMEBcv9JwFVpRWNU6y6hjdvrri52vHbb9+zXq3YbjeSeco4AWdK+MUy0HUOz9B5kshTadnWzgtCyuLiSQhcGT8oUnGLXACRS4RU1hJZSJRM0iwWvgtOWv3PojIzXM1ekpLjO5XsKFEW39eSOgBKyUJRAWvS4n2qyh25DMW9lZZ3vDxkQb1EPPNWbPGgzt7VmJaANGWgmiqQrd9lFQAVi1ZjJFj9aWdKiFeuyKCZGYBf1Fl178VPmqRA6wVWLX8BRV5J5pEZLOYfXqwDam6iJGCkPluWkxIvfAn9gcLai4vzCzCRp0i1reSE8ssCTlUte2LxaAvDqrbTAp3XZa14yReor0pwLUo4F4ws5VfuWxbGXLZFIUrfSHNDzW1CCapSkCokp8zXEtmuLlBqyq1R+lZ5l2ccCrBO5Rmy5z6pnE4VNaspqALkyxylFvco5dSZNZBqOcnXqAobpR+8PgQr5B0ZSSIigu2LJ61txOwBK+H9yzFf6onMEc27E0pJkCtKvNNaqZxYpBgGmewxR20hfSl75kp/03nMLwxjrQx63eGsQquvGKeRm9OBdq3Z7R1JTyQ1SODR6RnTrrHtmqACkcgpDsR4ZrOFVrdwspgx4HuPihHlFcUTrEo7KjK1TxGUJyjPlCImBppxBJvAalLyEEeiDyQV8XGEMPF0/0cef/6e2Df0naVZg7EdKU5CiUMzBnh++JHgR+5/+ZFpGlnv7nCra6JqWK0e6Q/PDOPI6dyjrWXQgclMJDeivEeZREyBcRLqXUweRklwNAwnnGvYb3Y0TUurLUZr7p+eAcXj/ZEYE5t1J1zX/RVKW7Tr0MZwOB1x1hBCg4Say+xjrXBZC6Sf27N0NukbJHEgzjSAX7/4/nqwOvb86Y9/oGk23L77DZMPjOOAaywp5gzSSuGahu1+w/XNNW/evmF4CUznyHq9kmCltsFmsX/vJ3ofCVE0Qn0UIXlQVcxWK7GO/DgwDSPDeaA/95yHnk1MdN2ac3/OmZgC4zgJ6IpR0kLW6VsieKMPGCUSWpurPa5t2d/est5u+Kv/9ndsdhuubm+IIfL8yz1hDIynCWMa2pxl6vmXe55+vufh53tS8kIPiB48+EnSoh2OZ87DmL2QGh08KkV8f0ZpxWa3xTUtlXyfOZPBS7o1g6NrV3z15Xuurzbsr9YCUYLIP/XHnpfnI/f3jzw8H3g69fiYc8knZOKyDt20mEZy8Lq2xVlHMhLANo6eEKcsgh+JKRCTBFy1KdB0K4zSTMee6SwUh+gsGCNcmxhqNHTwngnwkyRYKJ3ROYdWCh9GUoxoI+LEKhqxngtYNS3WNGhtISkm7+lSpLWWZCCYRD+deX545Hy1veibxUNbhkndokqLefXi9/Lqw68fKP9/HFpB6zS7bctvvnrDzfWOrz+8wViJ5JcwFfGKzkxc+awAinntlaevhkIC8rhMsirVbddZKqgsgMWPkSheJbliCfiRQB8VEzp71esO7EUV5kU6zZNUSQgAKUsj5ddP5HkWVynArYJVmRBF4ixRZbeyusElPF7CujwdLlUBErNntXpQs4c1A9MS6Z9SeZ1BayxgIwhA1YuUhDFccvOAIik613lFdaW3LpBTBUzZKFGl/86b5PL/0qmL8SJvTQVtcYk2qEkY0mIBTnM916AxVVuKAvuWQSaFc7ys65KRiwxsRH907ltqUb55Jp5/Xx7lc0tXebpPwn7U/MTzb+d6nceDyj1s7k/yZwbPSc1Ui8JlpcBmzaw1q2pdpspiLONI17YrxsyyfuQJIpLzee4HZdzNwVOS6joWoJmW5+fnr/04n6PT5VhJpa1yuym9PPvikDZTFaianF0o5j4iPp65RQoVR8oMaZHEpNgCqKz5Wman/J7ymVbVKJTHCVRt5tIpERUDVa+hUCbPORnUpoQ4mXRL2zlWq1ayHY5nlAnoZmIKPaOPBD8wTWe0VSjlECm4xDmNjKHHbBS6bTBtRA0RPh5hLAFqc92m7EGMRh4qqEgg0hOxMaD8JB5KayEOpHAkphHSQPQ9yfccnr7n6f4HlN8wrVt2WJp2IuWI+oBiitA/fWQaTzw9/EJCcXfzWzptSKbFNR2Hh3/ndD7hc8MOOhJ1ADuBCRWsep9ARUKaCFHm/+eXZwAO+2u6tmPTrrDaVMdTfxgw2rD9+h1dt+HmbouxLdGumKbA88sBazQqTThjcryRgNUi9k8KiFZuGVu5NcsWQPm8zne/bh3+9RmslCHaHanZYNodynaEnNGqeDqUAds42lXLarthu9vj9MjYaNpGixVkDUqLMH9MAlR9SPTnM6OfOB6OaK3YdQ1ERRzPEDyhPzKeXjg83XPqJwbvCYB2DW23Yrfdsll1xKtrdpuNLHBJ0jz25zPRJ6wTOQeRbdI4Z2kax+5qx3onWqnTMPLHf/wDYz/w8fsfAejaFtV77n/SHJ+fGccT2kSurlcM/YnzuSf4kf584vB84OnphcN5oJ8mTCNZsCygrcE2DmsdVsvS0p+PKKU4n47iqcaw6TZ89fYrbq+v+Obb93SNxRhFmCTy//HxiR+//5EffvqZH+4feOlHRp910IwRWbD1hrZZ0dgWgxav7yhR/0n3pDQy9RPRR5zdomk4ewVa07R7dtfv+eq3vyOMAy8//4hrWly7IbmO1K5YOYdtG+GmTqN4ySfh0XrvBaRmjq/WmqbpKHmKU4zZ4o4okzBGfmt04VZGpnFkHCdGP0nfw+C9wk+J5D/fucunIb364L/QoZSkGN7vGtarhg/vb9nt1nz95TtWqy6n7zXVEjVlm6V4UtFZwULl13mhmHMtC9mvAMcYQ5a3EdK7zsR34TmWBXPWwMyry4ypyh5+/b4+zeLvz1V2ongMS7Rx8bC+IgrOZ6QFBFcFQAk4TyqASlnuCvGAzFFGGUh+UoJLgyWDzgI8xZu68JZevH8NVguwzYEgKaKI2VMQ8fbTelCLghSDVFUgUL5S2Vs4QwtVKQjlkgUcvJZ6KXCmeJtV3Ypb3lxVyDZDuSVoUwW0Lds0paw9ihg8c8vUkqoLcyG/VwVkLmpjCQYTiBTazCNf1liaOzRl60PwWwac6eLhmOG8mp+x8npL5adaTpFmU+jS9xWUDFSljss9SphYAWSZxDCD9nzerCBxAckl0CoH7Ek1RKFPKRmnJfgzwdyKJe1oBcXl3GKMZABQb1nDqS7qpfAt1WvaDOJRdVZ0rpVW1QAsmdRkA6MSHuoz6RL8VjYGcppNbUrfEzpDWthLSpaV2tdycwgVKHuQZ+msRMhBxjZTE4rhZEx+jiTzSCKKs8OIsowxopgSNSQ8PhkslkQDccT3D3JfB67rIGo49UyIHrlNAdNodOvgHFEhSLtrxbSxqMag9w10luRGAkf86SdGDhzUkaZrWG3WaOVRjMSQOaRhhDDQNQO3t5rVytA0FmMjWnt2V2sSjm7d4VqLSlKet29vUNqxvb0jKUvTdqy7htD/htPpTPvwkvnNmmk4MhzvMeZEDM+FS4FzBussWhJAcj6OTGNkON5LKm1tBGRnQ9RpUT0693vQCnt4lLiIbkBpw/6qlVEWZTT5GLHKiGQlwj+XgNlikWXveUoEQWzM3Xo27n7N8ReAVU1yK5Jbo5s1yrjsjUvzBJnAWEPTOuGorjdoBoyJOB0wOmbPjAjzhxxRHmNkHAaGcaQ/nyWTUAwiiTANxDARpl60NE8H+jEwBfHNaCvc1/Wqw2iN1Yb1aqYlaJQAn96z2onkk8npXY2RBAWrzYrVeoVSimmc+Pn7nzgfDvz8p+9xjeX911/A6Hl5iJyPJ/zYo1RgvWlIaeB8FtmpcRg4n84cDkdOw8QwScYl4wAj8bJdt8K5RoTZk2Loz4BiGHqmccRgWDUtX77/wM3Nnjdf3KKJpOGMjxKIdjgc+Xj/wMfHJx5eDgxRvITWWqxSmevY4aykQVU5YiH4SdKbMZLShB9FP9XaDpQlmjGnW71ivbvl7fsP9IdnTg+/iByY7UiuA9fQrTestluG/szQnzn6F6bQSzTiOGX9VJsXToMzRjo3k2wp65gZmELLMEZArQKhiPipBtxJ9jGReolT3eX+7PHJ2vdf5cgLsNZgreJq59jv1nzz1Ru22zVv31xLf7SyXSNuCmYvYuX0lsmAHGFK9foUECEgo5DZY13kYoqoqElZTqQENsmWXfHSLHiOC0ypKmBNiwf6HDR8/VEBnjP6LYD1IulA/fnsz5X7pxkYiJu1cjEFFM2A9bWaQ/l74ZDKC2b2qBZh/xSzukWsE+ilhzWXJQPY12BVvgzZe7EEbp8WJuUOuvRaFc+TfD9vdy5P/gy7gPmsAqhmjuKMW2aQVq+1KFkBSQIIl0D1dcvMT5TgwtfPArAqtXi/fK7Sj2pAcOHyXnpC69OoRdepf+d7FMCuyvO8hq6F5hIofU6R6ra7yu5uoTekeutUCzo/dvVqyzJXgWrtr1CNoYvz67evOM7lfwW8p1i5mDGVDHKvDZeZkiHzwqIzKZB0TWpRCare79K0mA+tJDZA6ZmHO88iWVlAzz72wvlfAvfiKZPsd1QjaTlNVMBaOM2l7RIL9QpIxBpYFjOtJumZ9qRAksgwg9uYFEmDjkkoVdYQErLDWJQG0CQMKU3E8QSmzanDG4iGNOW03hL4gDIaXHYWZMMrGUidhc6grxpwGown0BOGJ0bOnOKJbt2i2GB1xBrx6gY/kOIIcaKxI3arsY3Jaa0TSgUBuGZF0zpJFKQD2kaurnZo09Ht9iRlcdbRWMV0fsfxeCbpNT6Aj4qxf0YrTwyJ8XSq0pK2MViXNY9DIobI2I8MfZ9VcKShGitSolfbNTEE+mEQia7TAdc4tI7YpmW9WRMjjL0XGcuYskS69LNZhnsJVoXXX01mVc1GLmfs//3xq8Fqt1rzu7/5W5SyGCtBVUM/0DQt0+TzgpElhDV0q47d9Q3GBUyTwPeQt4JjiEx+wvvIeZiYvOfwdM8wjJz6M85Z4nhFNJE4BvATw3BmmAb65JlQNUvSNJ6Fpzp5trst1/s9OQQXqxsa12L2DXELKqdftVpAbAiBse/56V//iLGWP+p/lO3/hwMpJRpniX7ipz/+K4W2EGMUea2+5/zywsvzC48P9zw+H3h8fOHp5cTLUYBlSNDttrTrFVdvvqBdrzFKrNq2W6GN4enjRwFm5xEV4a+++yv2uw1/+99+y2rVsN22+HHk3CeOpxPf//v3/Pzxge/vHzlMAdVtsCGhYqwgXOd2GMczSkcaJ9Hi0Uu9uNZjdBI1BrfCWRHxj3bNar3ld3/9f3H79h03d7fcjz3HhweGU49pWnAtqhGxeR+DCOkDkuc3oI3CNoa2ky2L1jXiMS1bPGiikZk/xYhKscqfGWvQRia+GD3TOHA4HFBOQ2/ANezWO1rX/uoO/p99WCOaqbtdQ9c63t5es1q1vH93Tbdqub65EsUJ12QvQgakhWtdZvpiECITvM4rZwEHlce5WHIWeIV5Oc1E96SqHI9afAvLzenKBpyRQ51bCpKgXmM+6so/A5EZ9bIErLMnanGbJThTBUzHet0anFQ+Kwtq4mLqm58pLZx6GXBSAutkAi/gtHhWqcC0eGKLnFUhOpfAKgGrKgYmU4LAyv0XrZDBRHm+WAT/l9N1XsBlPBU/U952TUu6wwV0YYbj+WnT3G6lv1zAnbRsRymXVprLs6rpc1GjcztnoFLEyGphirGTclvJU5jqPSvtXYDWstEWCCcDm9I/VAVwgoQSC1xYXov3MhsQsfaAGWipT96RvdoFts/e2QU+FmaFytvgah4jtb0rxl1aJctRVc5NtQ8Wr/Gyn6p6riqDexGJnlsoc1NTkt2VukWdf1tOLxH5OkC6bEjhhKr5NgLMJAJdAcoIACy2WCzlUuX73Fd1MZAW/8iOtUWbSrnjLMmVZvpIjLJ2hGwIqtKfUjEwvASQ1iC+PIfEHG8RI1on0AJrrbbEaDAByZIUJpSOoLXEaYw9RnWYtkE/afSoUCcPx0nWJWtItjy7IjlLeHcF2xa+vgaTCGogNJYxnTmfz3x8+ki3sgznllXn2GxavOjzcz4e6Y8HNp1m1RiMXeHaDc1qj3Ut1ji0tujwkRQ1cXyEGOlW1xi3EX13bbEmYfWKYd3QGkVjG0IEHxTD0HHatjx3H7HKCB1v8pIGV2mMDcQQGbpA8BE/jgQimc1EHwJKRSZ/wtqBwzDRNC7TNx1XN9e0Xcv++gZrLU3T0biW1XpLUBGMOAqdtXVHO6VASuGSYaNAlIFsBuz20kj+3xy/Gqxa53j7xRd4T43M9ZN4v0IImawt3BKdU5x2mzUhrohpIPZBOJHZG+u9BFONQ884TvSnI8MwMk4DRCepyIIieUh+FEAXJqYYCegsaJ/wOUgoxoCzlt1mwzCeGcchp0V1EqiltWiCZT6OBvHgxcjT/SMpRYYiaN8HnHO8ff+WGAMvj49Mo0TeS6Ypy9T3nA9Hnp+eebh/FLD69MLxPHIapuwFEpBhnGO9v2K92xOmHlIUbkuC0+GFaRjRAVrb8sX7d1xf7/jiwx3OaTQBoiemyDAMPD488fT8wtPpzJQA10qWnxCEd5RBTQK8n9BjZj5qw3gaSDGyTgmcwXRrnGtouzUxwYRle3XDV9/8nv3NFavNCmM1w+mEn0aUcWjrpOxa5cklT7h5kVcKjJFsXM41ogmqsw8jAVZnD5bQQFRKWGMyUNU5IE6Agw8Tw9CjgkJ5TWMsq2aFK7Ik/1UOdQHrFp4HaKykGb7atWzWLV9/ect2s+LduzsBqW2LUjMPbglBKtDJq0EV/M4LrdZpEVA2o0alFmfnFbcshvJStj5jPaFGQl+QUcuyTQWb83Zp8aZ9ZqIpz3+BHNNcsFyWClhfHfNilkGVmrd5pYgFrBaEUCBbDetZPu2FZ5SyzU8GqzHVfhyjgNK4BBKpfJageFWzMVyijcVrF4nef4IKxGuZw9pL9ZdqWmD4VydVwJqh8AJg5Qq+6HGfY4bOnrK5T831x2WNMrME52vO1/pMKyt1+Uu1/DyXcik5Ucs/g7NUTv4EsKqFg3LuZ2rprsuvly1dnmZ5l/n75a9qfdYyzuzQS2LDoosuxlLF+/Wil317Xp0vPl0YIAW18aqkFze7LEvlHhegnAF0WjwPc7lS5qenC+Nk8VyLOadu16tM4zCLeo4XJ83nqkVTqIuvK+2nfpYWrVCeW5XniJleIxSx2dNbfpuDsFKJHiePy0DhSdY6UIU0pCSBQ4zE4Oc1P3iCH3G2xVjJLqUCqCGghiB1pbMhLwRcktXE3Yp0tYY31yQTmfwzQcPERD95Di8n/KTRWFJY4dyWEC0+Wo6ngcPTCavWdE2D0g5jO2yzwjYdjRbDIcajrI3TCRAeqG06SQhTPLHRsW4tTiusbQWsesXQWpqcjXLoz4zDxDSMtVdrHUgh4Jxlcgatc3BkynHOMuEw+RGAw+mM0YpV29K2DcfTSLdq6ftRQOt+j+/WGCeKTsYElNNYZCd17tUxN3Sal7OsAlAyWP7a49eDVWPZ7W4YeglyGon0Z0XbtXgfcE4CZ5LVpMbQrVs2uw3T+MhwhqAVUSmG0TMNIy8vB4Zh4P7+kb7veTq84L2kQU2rFk3AqAhpIqVACInRR87jyIjDWkMKnvPzA36axDuCAmuxao12LZvdjm61rtbrMEjwlTSSKAyEEDjke4cxYF3D+69+Q9O1bHYtQ3/i408HTscjv3z8mAeiZhpH+uOZj/cf+f6HHziMI8dhYApRxI3JnMPTmugMV2GiIXI8vDD1PcPp3whTIAwBZx2///Zbrq72/PXvf8Nm07Hfr1EpMPYjYRp5eX7m+eXAw/HMx8MLP708oozFGEfjGrpuVbkn1hoUCaPkX8ratU5JooDdWvRer96+wzUd3WaLUpqbENnt97z/5j3GaJ5++pHnXz5y7keiNqyubsAYsA6fPcwhSHQlKokmq7GAgFXrJEGC0SbXuQTSxRgz/0g4UFrrKjtVOrdKEykYpuFIp9bs1ntcs6b5TwarlTmat7zaRmOtYrMyNI2max3OGrqVKC9sN1uapuHq5oqmcWw2G/6/9s5syZEjS8+fb7EByKWyssnpnh6NNNNj0vu/jXQlmZptGoqsYmUmEIsvujjuHgFksck2WdvwIo5ZFZBAIMJ3//0s/7FGkjqINWIDVFWdzTUDjNLrFlolr/4aJRbAsklnzWyhEqnXVvCYN8Dqy7a9680zKCFc+VZ1sVkBL2WT2wCjVUu13q5ENd8iniuwewXk8paegd9Wy8q2CGUjL9pZVbSSJdBsBX2kVE2+RVsackBUYQAIYfVVrRrVjavAqlFNpJSBafAU6qrFxivNqsqtuLYPqya2XFaVopsGSGWrfo8wroFnAYUryf9Vb+TmjTofcZTcW1de0zLXdNWMVoNwLnCsXVmetT1OpdoZt9BMpWI+X83eibRSU1VVd6rW7Do8UqosA2K2L9HFMhciVHBV+jdBTX4QY+nnXJaC1fIhi1R1cwI+6/2pz1j12sUnOiE+sGrTXWlzz9IOKyRVmzpEAnJATxWslqmS6jCItQe3h5EK+aqWuTxSWIFDkqeZqK76T6299HXNqlZoW8zlZT0owVlhrU1dTsoaJatPLUvugwKkS9Dw9nOlMleFSiQth8RSD2cNJmlSMqRETpOdUKkkU5X7rUwcVBP0+lz5nOI3qyxGWfCJ5TxiW43uNPM4cxlnlP6M4oWD8rgeTIriEjAl8R7pDKrRguQ6R+otaXCkQ09yiqRsBsszTWt5agVMOptAG2YvZdHK0g13KNUz3PW0hw7dHkmmlWDwZUF3YoJPSRFD4uV1ImEY7h1Wt7i2QxlLigYdD5yOj4QYOETwi+dymegaTdcKo45rT7x++YmXnz4Tk9xX1vwI0dA4i1UwjROXS8T7xDRlN6oc6xZCcdFcGKfAefoeYzTf/eUHnHMMxxP9cOTh6ZnD4cTDwxNd2zL0HVaL557Go/BYFTEq5jEVxYMKJdlF/x6aVaU1bdsRQuLy+oZXRbMa6oIujtQyAZyztG2DMWYduErhQ2RePOM0Ml5GXl6+cLmMvF7OhBhxSuNdifoVUFk0GzEmlhiJKmV+18gyXqr5TjZ5g80aXtf2tF2XvxcQKZYM8WUKGXCdz2/4eSFFRacMw/FE17e4DpZlZJomKePruU6OZV4Yzxc+/fSF7z994hICl+DrUqUyWB3nCTeN4vYQPOM4MuX0rGHxdGagGQwPpxNPQ+wmIgAAFthJREFUj/d8/N0DXdfQtYbgE3OKkk50HLmME5dl4TzPvE2j0FEpTasU1jmJolSIhpJyUs4bbUxYZbHK0DYdbdcxHE64rqc/3NVgqOPdkcPpQFhmPv/whfHtjRAiGIttu3zq1IQl1YAUcl9J5l3JBqaNQRmdA9o0OmtzYh4neYlbx0xFTlvTsSQpMErRNx3WdVjb/k2nsb9Z6j79fgIpwAg+lMmoFH2jaRrNw9HSd4bjoaNtLMfTkaZtON0/0jQdx7sHjHXZIsAKgupWtAEhpQzV3L0twebdZkOSyzcax+vbbZEAZYT+3L3U9V3rTUQTstX8rNe+a626icH1WpTeX8QWeqXNv+1LWt9vcR2QSlatXO9UfU/lgpgKFNiA1ZiEeSSD2BiTJLiIWfMaV19WCljdaFRTzH5YGazq5AneXoHV2jrVp7jCjusK1LqlzWebRrtF6+/kqz2w/rw8X23AjHxADYbYjJXb3n+PmdfeKhdcj4q1gtdGbmow0/bz25K/f+YWCmfAlNho5opJeW3H0pyorxQ/l3/VQ65XJEp35XupooHe1DBtSp4JVwsr1nb8XrdKXOu80fTfKp8Tiav5p6ggdXsoLYO7PimtwLDsP7XUXxkaAvZV9l1dfQjXtS/PpVKLMjZWFXq9z9X43ZQxbR5eaqSVysoNKMk/ktE5A5bOYFWsFamcbDaLSU3WUa0e6+NjymGjquhWjfiiey9KtCBR78sSSIyAolUG66jKvxgiKnN2Y2RuJGdIVgstlbOkRosfa/KS/cpohsbIOkBAKU2IeV/TGus6UC2u68WVTjekZPDLTEyR1rocwGggweLLIcGCFkumNoYUEslKoFWMgSYlZq0Iy4xREpgbo5UUr0ExjwsxSZZOq2WPns9niAthHkXbmgLLIvtyCEnO3inl2JaE9xFPZJq99IF+w7qG7nVmOMzM0XIaIamBvkssXmGNuP1q5TEq0JiE1UlSrKuM5VI58PwdeFYL+EkxMF5eaRpH6C0xeGLODSsUVpIdyFiNa20OzHEsypCS4jJNnC9nvry8cT5f+P7zF94uI5d5RivFPzx94DAcRP3sGmlQpcE4lOtxh0fAot0AaF5eXnGuERqG4cjDh48bp/Hst6Nl8BrrSSlVs/bbl1fmeWZ8O6NQPD//geF04vR0wBjN+PbCNI6cx4nRe5IVGipjHHO6MDMyRcUYFHOSHPNXkiJfvvzEOE7EpOj6gTDPqBDpdcepHfhv//XfeHi451/+9EeGY8/QG4yOhMUzTzOvrxc+f3nl//z4iR9fXjjn3L4qJXSMKB/QgDEu+8MqtDY12rNxlnmaxNna3tO6luHhA/3pwN3zM23fczg+4FzD0PcYrXj99Inzl5/48//475wvF7r7R5LR4Gx244n0Q8tBHzi/vXA5e6xtiE0QJ3iVfU+VOF9rq2hdK35x05z9UcfN4rousMV7whrL0B95fv4DH3/3Lf/8r//KrAyjMhzufn1c4K8VoxStlYW7saoGDGit0Ea+N3r1QXVO2C0OB0fXWo7HlrZ19F2PtY5uOGCco+1OGNNgXJPHYcEe6WZzLV5wK2XOCljfT+Yt3KxajxLlr+S1qC6KxvadOZiyacm3Ojuxlaw1W9Bbgna2fmmlHGz+Xu98DYgrwLzBXXqjPV033g2oTGUjhsphud3gcwFSvbeqSR6ufVBXiqoS7V+/L8wkIZsUqzaVNaAqmxy5AqkBwoJoVhcas82RXZqwuG9kbXZN7SNx5av+tDTA2pIqiXZ7DRMq+EnAecwNr6nGvusBUhopM7YUlv3qrVnGhVlh1uoRWP4uHbcFPivYvPULXVP4rBANUta0ZuBfQVsG/nXTup0TKZvpt+4vrMH6RdOYU72mqqbW9ekrXlwBmWhIC9y8hbLr+Eq5rqrWVOWyFD9dlemUEOuBWmuuMjiVQMeYffuvtfsq3YzlWvbMc5tB+eoOk0uYCoCWkZFiIiqNT1o00pntoFCZrUB28xQjgT4rDfm2PTZBjQXY53VAF/aNjS+xsFmseLWYede+BpVUTtMN+EBIIWvbo+wLGfSTEqbUM1MOFB9z8fOl7hfFkpK9XLNbjcTOJOVQqsUY8a2MYWJ6HTEJhtYQlZU2U5ZL0sTnhHET5n9+Qo0LPluSosv+wH4iLQbmMzEZFpXwYeY8nnGN4XjfY5TB6AZtjABMpdEq4BoLNLSNxpjI60//zngexV1BafQ/fMNgDjTtgaZ1fPNP/4g2LQ9Pf8A1rViYoycsb6TwhtHC4zrNE8u4MJ1H5uiYwkDgQHd4xIeOmHqa7oRrDxBGUpzpmobzy/9l6A3T5Y1x8viQ8Ev2gY6WGGGZhZf+/DYSfcTPIa+dQs8lvKqa6exJ4QvT7GumRWstxlpx79OGxiqshsaJksco6bG4KLpOrYkUfkH+pl1f5ZEvPqJqYypLm0U9D3at1gjvHN0cE0L8vyyM88Jlmnmbsvnce6wxOOdo2lYqbIRgWBxiRWVsmp6IIWop+rwsWCMpUV3T0nW98KsaRZhnQvCrr1/WPIYQJEhqnpmnibgEtDH0w0HSW7aSmtX7Bb8sLJn7tGhutXUoMwspiVJ1slBPk6ssy0IMiS+fPjG+nWm0wWpLe7rj2B/55vkjH54eeHg80XbFv1N4S733TLNnnGbO08i4LCz5VKLy5KxUI0pOcbXNtbzq4i8agwAu43BdTzMMtMNA2/X0hwNN03J3OpKC5/z5e8a3V/HVjQnbdkQtdVWZDsYYjXOOeTJoJc81NmtVy+KjUgV91jk5ZaZI8LB4VekvVvO3LFiV7so1HI/33D888uH5mbOPpNlj/3+9ANQGGOf3VkNnhR6lazLAKEDVZKCqFdYqnFU0jaZxmsPR0XWWw6GlbSTxgrGOpuvQmS9VG7ty/mZNdEUEVa4HTony/9qZ8wbv1bZT5cNqqis7kbrRbt7+uny/vq5IlvXfDdjdlmjrI7nurNvXfOVG1Vrhw0Y7UjWoaQU2FaymvN2/2+DzvfN4KkEcwnsKMYVr8Mrqoyp+q6FqVmMsYDXXKxYAKyYsgnDAxLgIcA0LpIBKC36xdXO+6Zp3LXftGvG12pQL1WrGrr+Vz9cmzubylOdSjQxP9fur/q5vVe3iOqauhuYKVAoQyWiEtbe2qDhRM1XVb/P3lSLtur4Z6myxGNurCoAu39dhuK3eBnKu5d42GO+ecHv1X+mBWg91VTOo/gvlzklVgLtC9Vh/vz2IZVwm7bXpD/J9CvJdXT83B79a5qyZVQX4pupuIcV7f1gsUjSqxRehFLselep6kOd2YWLQW838pvG2dcigNlUqvTwuM9Vs0Cn7lwQKKJc9IFZ3AUUSTtMksF+lJBH7qApSywpSXFVWJwphEACLyvRM0UPwEqhltOADpTTJWAKGMLSoJa/52XqLgpDrIZywOX4kJDFwh4ifPcYqjJE04a74uipQKqf1NhZl5BpUZJmF1Ugph9EWHxMxaVAWbRqG4QFje+E5txbwoggMwiygclmCzynq/YIPhiWCsg22OeLahaZbGI6P9Id7oj8Tw4ifPqHVRPSvWBuxrc+ZxWzWbDekpJgn4Uw3xuIXz3xeiDHhAyhjsEb8fWMIzNOETzEHTDm0cxjXYI3DaEfjNFYrcZkz4LS4DBIA8x4z/Zz8arAq0fAzMS5Zu6RprEUDszg8UMxlKYrpmmzyVVqLz+lcwNfCy8sLX15e+fz2ynkSxO8ax8ePH/hwf6JtG8ldH5UAIJdwQ8PpyXGeFi4vFzSaZDRdf+Dpd99y9+GR7jTU3S8A0Rcta+LtVaixpkkSDIzZ/G90Q9f2PH77RH/smccL8zTy/f/+M6+vr5wvZ2bviWictfTDIMT97g3XtPTtgE2RJgXxffU+R3YrrGkx1mG9w6qG//yf/pnHh3v+9C9/5P7+xLf/+JGua+j7BqVgHkeJ2psXpnnmZZp5C5HJWCYU07IQk6ZtDwKesrYu+IXh/p7hcBJgpBRKXfBhQRExBvrjkb6/Z7i7ozsdaPuerhs4Hu7o+p7nbz8wnd/4/Jf/xXS+4EMAbWmHA0vwjPNEJBC0J86SFCL4BWM0TSsO67LsFdCsJAmANbRdJ/yytsFnIO6Dl3SVZRFUMs6UUjjbcffwgf/yb3/i9PhAd3fg8+cv/PuXz7S643nofu3QvRKlFEOraazm6a7BGkXrLEaLtlTWaAEyPoOZkEr2poQ1Snh6rUbZEhCWtSpqsyGVTS2DIqMLY2PabJ6b+VX+y5tHjcjPG4EqKCJvYoV7tVJb1dR1ev27LN563RC2h7b6WeHI21xXNbpr9a5/c/vdpn1BUYK31oOI1FtrqLQzpFWRWHhhZbHJIHPDeZq41njWa9l8JlJYAXzOhlfI+kPWzETiJrAqJ8SIKUclx+o2lDI9VQWrKWZGkyDciZJyLoPVmdmld5rV2jqFLkkVsCOf3UZNy9olfselzQXUbBb1osbKv40bEKZSQiedr5coGVWcDvMB6DaKvh4y1MZTNG3BJisIU1nbVcdsUVDkEtRsRCUhRQHSeS4ge0RxzViBaMyvwkG6HloUSW9tL5Dqb3NUfJ4X203vq6D1RkrwWvFhlXurCvKugHGZ1yXAqugts3Uo6zQzlWMBYqmO5QJSy29kiYi1zIn1QLnxysjnjBwTkCdc8egt91O5XXWMBCVrQ7WOlDa7aQulRMuVkrSDyemaC69pKprgJGlJStY7U1zM8v3kGjkASt1k/VnXmFQtVN4LxaKOEDTV1UYWO6mVVgllJQGIRgoomU9TTSqQhEgVlWLNMJwQfu0YEj4GiarXPUl1QAdpJgXF2+vIZZw5Pg50hxZxWO1IHzv8EFB/foE5oqYZRUK1jtQ3xFMnbABGCRlDEFcF11iMgRQmcVNENJLLEmicpW0cthmwzUBCsjM2TsOhpek/YpsjtjsRtWPyE0v0DO6ITollUQSv6sE4LRPRz/h5YrxM/PjDhXkOvF0kpiRqaNuG/nBPCIFlnrl7/MDd4zNxGYlhomHk0jl6F5nGAR+ECdjYE0o3NO09Wkka7xASr28j8zTx048/Mk8Tb68/EXzA+5kUPDF8IXqFXxQehdBEGJI2EnCvjQRZGytaV2NpWuFVt8ZwTJYl/vV5WuTXuwEohTOKxmn6vqFpGtrWYZ1BsfpzldSDEuijcI2j7VrariWEJQM9T38Y8DFynO8wy8Kp7zh0HU8fn3i8O3I4HmmMxsSACZHetIQl8tgMNJcJj6ExDX3bc3d/z8OHB453R9q+rcA5aEX0Omc0SjSNk5ShrUMr6PoWbzTOdHT9wPH+QDt0MiBy+2mtafsWExw2Qtu0HI8nSSCwzPggWbN83gz9IswFhQrGNqJZa/VAY1u+/eYbPn74wB//6Q/c3R84PQ5YZ8RvKAowAgH4yhhM0+C6jv50YF48p/sTrrE0zkoAlYa27WjajrsPDxxP98IVpxTav6LCBN6hEtw/PNANdxzujnTHgb7vabuWrvzrO4gCPq21tH0P1mGPR5ZlQRlNVJ6olryogzOatmmI0cu/nJqw+KG2OZrxcDxirSMUBokor9F7lIK2cbL0pYC1jn44cDwduXu4oz8OskiqRIyeko+6yOFw4Onpw68ax1opjp0kqfjdQ0djNX1jxRJgdV18Jatazq4Wi2kzZedxhcuBVUPvaFsraYSdUHoY42i6QZgTzIDSFmtsBQzXPmbkz8qELVpxuV4Vy0Q17ZsMxlawWgjblZLgtkx8h+Q0UkL7ooovl4xplBwCZSMxKwhVxZ1g9bcsm7ZQymw1IdRDWb6kugvUHOBlYy0wKHOhhkpEkEFJXrBqUBWreX4Fq0U7l6rmk7RyQFawimzC1igBoUGtZn/yRpzna8o+qgJW9cq3WqKTK41VZtUOyPirrxKEoVF0bSNm0s2a2biGlEJu64QhZE1NPtzoklSggLOEpNOt+ahKVmIB+KlWe4NopB3LkzWG4gqiNsChpNasGd42oCihZRxt3DJKf2yBXwnAicUlI+dQL1KZFPAC7AoTRdG4ZmATMw+2qsBQULno17KZPmYgqQUA6g1fsLwRB4io8rwtZYlF8xavyrYdI2nzbVFuqjyvboHd1cmgviu+dsXHVOcnZtcFNu1SHlJmQioa1gxm64GuzCVNgeJSsFXjKLNQ1xKpDJQ1CpOzJSplssemqfNUCPNXMUbTOJeBZsqUhypb4lZXGaXzoSPJ0wuoLXO+0L+FFPKJZnvwFZO+vNdC3u/Fcqa0J0Ut8yuPQ62Ee7txiOYtj5tUAh8z9RVRE1NCG5mrEm/B1dxLKZKsA46QLhgr64EPZ7w39O0gfOzdEWwvIKtN2KfPaCz6Mkt/3TekQ8Py8ACHFoYDSSlsiMTkcVHjHGKNyzN3QWItnHY0xuFsi3UtxhiUNvRdxGlHe3jAtifatsU6cfjROZuYUaCTl3YOAlZVkuQuWhm0sqgkwUnGgDENyTq6tmHoOuLcE4eBwzBwPPREr4newd09jVqwnJknR0hycDbNHca0tN0jRhf/V3i7TMzTxNA3TNPI609OUquPF4KPLFOSA4LPcycpkjIktGgmioXdaJwT1h/bCHi1tpF98ispt78m6taXZSvfffdd/TKEyGWcCZm3TCuNsRatDdbadZPLm0gMUfLy+oWQtY0hhhy5n9OixiAay5Qni9Yc+z5PJLsuBxk8hARzLLRGQSaq1ticGMA1DueKjXizIGTx3ssGWDQtXnxYi9m5Pw6ShzhrW5ZpIoQoGsB8K6UlS5S4EoiGcFl81UHUnOGlgTPQ0Hnj6LseZy1d32CsySBsPVUXE2SZmD4Eaad5xvvAPGWu2li0C1Km2h/Grma+kgoyyqnX2k76q3OoTMElv5OUac45Ygw5qEpYG4rrQ9VMbcxM9WVjsr1d1FXJPZ2j/sq1Prd91YGUE31+r7WRZA/HkwRpWcOc3SJaq2ntOsD//N1f+OGHH395tGcxWYvrjM7k16umsMhWW3cV4V02+K1Pa1nkCyCsIDOfNFk1jty03c1b6jaw0YysRVOb69XVb7j9zVc+v+qZzYZTrrnaom/8Bt6dfcutbzU2X63TRioY/QUpgKxu8Jsv3t/u9qf5u82GV7/Y3DVdv1/x7/q7qztuABek+rdouBLGaJ6en+saFGLg9fyWs/yVXrup/0ptcCNru6afu+TnfrFRCW77XH1lyGyvfHf/X+ykTVvVD27a7GpArFdvHUfeP3N7T8VfL8im3FsN7y+U+3p0rbpH0bTePH77k+tJUj98P+5/rl1ui1HA6vZxX9M0pQo8t1OhQn21/V21qdRft23L0PX173meWRa/uZvi6halbDe1uX7C2qO31SvUVdu1bMXn2zm0febXWErS1dxPrH1UuYjT+xWxlDlFT4zCKJQyl2sMMWezVKBzEpYg91RvIyyh+iJjhcYqdU7Al5Xg7Wp5qHSN22aTQ3ndE7Sp+wJQLURKS8CtrgcAEW0cxa2v9sNmzSluS96H7AecssLC5oBmRwiBEBasa/JBJUGKhGUSpVKxENUOkzJqbWvvJsiH+Eio2MnXgz+kali5nrartUO6X/ycdeULz/VV4pLx/HyflVUiv//97782AX49WN1ll1122WWXXXbZZZe/l/wcWP11+tdddtlll1122WWXXXb5D5AdrO6yyy677LLLLrvs8puVv+oGsMsuu+yyyy677LLLLv+RsmtWd9lll1122WWXXXb5zcoOVnfZZZdddtlll112+c3KDlZ32WWXXXbZZZdddvnNyg5Wd9lll1122WWXXXb5zcoOVnfZZZdddtlll112+c3KDlZ32WWXXXbZZZdddvnNyv8DuOrOh/7FMXUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pied Kingfisher   |  White breasted Kingfisher  |  Laysan Albatross  |  Glaucous winged Gull\n"
     ]
    }
   ],
   "source": [
    "img_grid = torchvision.utils.make_grid(images, nrow=8, normalize=True, pad_value=0.9)\n",
    "img_grid = img_grid.permute(1, 2, 0)\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.title(\"Examples of CUB dataset\")\n",
    "plt.imshow(img_grid)\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "plt.close()\n",
    "print('  |  '.join(f'{class_dict[labels[j]]:16s}' for j in range(NUM_IMAGES)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4WLYRpiPiRTj"
   },
   "source": [
    "## Few Shot learning: Euclidean and Hyperbolic Space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kdpHPlb0jvHU"
   },
   "source": [
    "First, we set the value of hyperparameters, assigned using `Config`. The hyperparameters are set for 5-way 1-shot task.\n",
    "\n",
    "\n",
    "Note that we train the model for 5 epochs, but to reproduce the final paper numbers, the model should be trained more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "mVy4wmo3jtgt"
   },
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self, shot=1, lr=0.001, step=50, gamma=0.8, c=0.05, model=\"convnet\", hyperbolic = True, dim=1600,\n",
    "                 query=15, way=5, validation_way=5, temperature=1, dataset=\"CUB\", lr_decay=True, max_epoch=200):\n",
    "        \n",
    "        self.lr = lr                                  # learning rate\n",
    "        self.lr_decay = lr_decay                      # Boolean, if to perform learning rate scheduler\n",
    "        self.step_size=step                           # Period of learning rate decay\n",
    "        self.gamma = gamma                            # Multiplicative factor of learning rate decay\n",
    "        self.dataset= dataset                         # Dataset name\n",
    "        self.model = \"convnet\"                        # Name of Base Model\n",
    "        self.temperature = temperature                # temperature used in calculating logits\n",
    "        self.max_epoch=max_epoch                      # number of epochs\n",
    "\n",
    "        self.c = c                                    # Curvature of the hyperbolic space\n",
    "        self.hyperbolic = hyperbolic                  # Boolean, if it is hyperbolic or not\n",
    "        self.dim = dim                                # dimenionality of the output vector\n",
    "\n",
    "        self.shot = shot                              # Number of shots in Few shot learning task\n",
    "        self.query = query                            #\n",
    "        self.way = way                                # Number of ways in Few shot learning task\n",
    "        self.validation_way = validation_way          # Number of ways in Few shot learning task for validation set\n",
    "\n",
    "\n",
    "args = Config(dim=512, max_epoch = 5, hyperbolic= True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "imLdXgEPs3E5"
   },
   "source": [
    "Split training and validation set based on the `Config` for few-shot learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "U8g8TRexj3so"
   },
   "outputs": [],
   "source": [
    "trainset = CUB(\"train\")\n",
    "train_sampler = CategoriesSampler(trainset.label, 100, args.way, args.shot + args.query)\n",
    "train_loader = DataLoader(dataset=trainset, batch_sampler=train_sampler, num_workers=8, pin_memory=True)\n",
    "\n",
    "valset = CUB(\"val\")\n",
    "val_sampler = CategoriesSampler(valset.label, 500, args.validation_way, args.shot + args.query)\n",
    "val_loader = DataLoader(dataset=valset, batch_sampler=val_sampler, num_workers=8, pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Er3045V3tJ7B"
   },
   "source": [
    "Now, it's time to define the model. Structure of the model is based on \"[Prototypical Networks for Few-shot Learning (ProtoNet)](https://papers.nips.cc/paper/2017/file/cb8da6767461f2812ae4290eac7cbc42-Paper.pdf)\", NeurIPS 2017 paper. Hyperbolic Image Embeddings has picked ProtoNet because it is simple in general and simple to convert to hyperbolic geometry. ProtoNets use the so-called **prototype representation** of a class, which is defined as a **mean of the embedded support set of a class**. To generalize this concept to hyperbolic space, Euclidean mean is substituted by *hyperbolic average*.\n",
    "\n",
    "Once the prototypes are calculated based on the average of data points, it's time to calculate the distance of the data points with the prototypes and perform classificatin based on the calculated logits. To calculate the distance in the hyperbolic space, *Hyperbolic distance* is used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cgkVYwnFxg9_"
   },
   "source": [
    "### Hyperbolic Average\n",
    "\n",
    "Let's first define Hyperbolic average. Extension of Euclidean average to hyperbolic space is called *Einsterin midpoint*, which takes the most simple form in *Klein* coordinates.\n",
    "\n",
    "\\begin{align}\n",
    "HypAve(x_1, ..., x_N) = \\frac{\\sum_{i=1}^N \\gamma_i x_i}{\\sum_{i=1}^N \\gamma_i}\n",
    "\\end{align}\n",
    "\n",
    "where $\\gamma_i = \\frac{1}{\\sqrt{1-c\\| x_i \\|^2}}$ are the Lorentz factors. The Lorentz factors is implemented in `lorenz_factor` function.\n",
    "\n",
    "HypAve is in Klein coordinates. Therefore it is necessary to transfer the points to the Klein model first and then project the calculated average onto the Poincare model.\n",
    "\n",
    "Let $x_\\mathbb{D}$ and $x_\\mathbb{K}$ denote the coordinates of the same point in the Poincare and Klein models. To project the points between these models, the following equations are needed.\n",
    "\n",
    "\\begin{align}\n",
    "x_\\mathbb{D} = \\frac{x_\\mathbb{K}}{1 + \\sqrt{1 - c\\|x_\\mathbb{K}\\|^2}}\n",
    "\\end{align}\n",
    "\n",
    "\\begin{align}\n",
    "x_\\mathbb{K} = \\frac{2x_\\mathbb{D}}{1 + c\\|x_\\mathbb{D}\\|^2}\n",
    "\\end{align}\n",
    "\n",
    "These projecttions are implemented in `k2p` and `p2k` functions. Finally, $HypAve$ is implements in `poincare_mean` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "NpgTlZhb6RYL"
   },
   "outputs": [],
   "source": [
    "def lorenz_factor(x, *, c=1.0, dim=-1, keepdim=False):\n",
    "    \"\"\"\n",
    "    Parameters\n",
    "    ----------\n",
    "    x : tensor\n",
    "        point on Klein disk\n",
    "    c : float\n",
    "        negative curvature\n",
    "    dim : int\n",
    "        dimension to calculate Lorenz factor\n",
    "    keepdim : bool\n",
    "        retain the last dim? (default: false)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    tensor\n",
    "        Lorenz factor\n",
    "    \"\"\"\n",
    "    return 1 / torch.sqrt(1 - c * x.pow(2).sum(dim=dim, keepdim=keepdim))\n",
    "\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "# Project a point from Klein model to Poincare model\n",
    "def k2p(x, c):\n",
    "    denom = 1 + torch.sqrt(1 - c * x.pow(2).sum(-1, keepdim=True))\n",
    "    return x / denom\n",
    "\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "# Project a point from Poincare model to Klein model\n",
    "def p2k(x, c):\n",
    "    denom = 1 + c * x.pow(2).sum(-1, keepdim=True)\n",
    "    return 2 * x / denom\n",
    "\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "def poincare_mean(x, dim=0, c=1.0):\n",
    "    # To calculate the mean, another model of hyperbolic space named Klein model is used.\n",
    "    # 1. point is projected from Poincare model to Klein model using p2k, output x is a point in Klein model\n",
    "    x = p2k(x, c)\n",
    "    # 2. mean is calculated\n",
    "    lamb = lorenz_factor(x, c=c, keepdim=True)\n",
    "    mean = torch.sum(lamb * x, dim=dim, keepdim=True) / torch.sum(lamb, dim=dim, keepdim=True)\n",
    "    # 3. Mean is projected from Klein model to Poincare model\n",
    "    mean = k2p(mean, c)\n",
    "    return mean.squeeze(dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qmDsLu4j87no"
   },
   "source": [
    "Now, it's time to define the model `ProtoNet`. Whether `args.hyperbolic` is *True* of *False*, the model can be Hyperbolic or Euclidean.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "evNlG8NoiwVQ"
   },
   "outputs": [],
   "source": [
    "class ProtoNet(nn.Module):\n",
    "    def __init__(self, args):\n",
    "        super().__init__()\n",
    "        self.args = args\n",
    "\n",
    "        # Base Model: ConvNet\n",
    "        self.encoder = ConvNet(z_dim=args.dim)\n",
    "\n",
    "        # If working in Hyperbolic Space\n",
    "        if args.hyperbolic:\n",
    "            self.manifold = geoopt.PoincareBall(c=args.c)\n",
    "\n",
    "    def forward(self, data_shot, data_query):\n",
    "        # 1. feed data to the model\n",
    "        proto = self.encoder(data_shot)\n",
    "        \n",
    "        # Hyperbolic Space:\n",
    "        if self.args.hyperbolic:\n",
    "            # 2. encoder is Euclidean, so proto is in Euclidean space and should be projected to Hyperboolic space using exponential map\n",
    "            proto = self.manifold.expmap0(proto)\n",
    "            \n",
    "            if self.training:\n",
    "                proto = proto.reshape(self.args.shot, self.args.way, -1)\n",
    "            else:\n",
    "                proto = proto.reshape(self.args.shot, self.args.validation_way, -1)\n",
    "\n",
    "            # 3. calculate prototypes based on mean of data\n",
    "            proto = poincare_mean(proto, dim=0, c=self.manifold.c.item())\n",
    "            \n",
    "            # 4. query is projected to hyperbolic space too\n",
    "            data_query = self.manifold.expmap0(self.encoder(data_query))\n",
    "            \n",
    "            # 5. Logits is calculated based on the Hyperbolic distance between data query and proto\n",
    "            logits = (-self.manifold.dist(data_query[:, None, :], proto) / self.args.temperature)\n",
    "\n",
    "        # Euclidean Space\n",
    "        else:\n",
    "            # 2. calculate prototypes based on mean of data\n",
    "            if self.training:\n",
    "                proto = proto.reshape(self.args.shot, self.args.way, -1).mean(dim=0)\n",
    "            else:\n",
    "                proto = proto.reshape(self.args.shot, self.args.validation_way, -1).mean(dim=0)\n",
    "            \n",
    "            # 3. Logits is calculated based on the Euclidean distance between data query and proto\n",
    "            logits = (((self.encoder(data_query)[:, None, :] - proto)**2).sum(dim=-1) / self.args.temperature)\n",
    "        return logits\n",
    "\n",
    "\n",
    "model = ProtoNet(args).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E-El1RFHIIFe"
   },
   "source": [
    "Once the model is defined, it's time for the training loop. Let's first define *optimizer* and *learning rate scheduler*, alongside with functions to calculate accuracy and average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "pNGO4PiDIWsK"
   },
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n",
    "\n",
    "if args.lr_decay:\n",
    "    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "5WTG2rPBJcfa"
   },
   "outputs": [],
   "source": [
    "# Function to calculate the accuracy given logits and groundtruth labels\n",
    "def count_acc(logits, label):\n",
    "    pred = torch.argmax(logits, dim=1)\n",
    "    if torch.cuda.is_available():\n",
    "        return (pred == label).type(torch.cuda.FloatTensor).mean().item()\n",
    "    else:\n",
    "        return (pred == label).type(torch.FloatTensor).mean().item()\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "# Class defined to average the values passed to it\n",
    "class Averager:\n",
    "    def __init__(self):\n",
    "        self.n = 0\n",
    "        self.v = 0\n",
    "\n",
    "    def add(self, x):\n",
    "        self.v = (self.v * self.n + x) / (self.n + 1)\n",
    "        self.n += 1\n",
    "\n",
    "    def item(self):\n",
    "        return self.v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MXHCH8bumdZ-"
   },
   "source": [
    "#### Training loop\n",
    "Next step is training the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "U7Y6_MSKI8bg",
    "outputId": "8b5f3065-5dac-4d8b-8323-be88f4be5fff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, train 1/100, loss=1.9849 acc=0.3467\n",
      "epoch 1, train 100/100, loss=1.4964 acc=0.3467\n",
      "epoch 1, val, loss=1.5653 acc=0.3891\n",
      "epoch 2, train 1/100, loss=1.6622 acc=0.3067\n",
      "epoch 2, train 100/100, loss=1.5009 acc=0.3867\n",
      "epoch 2, val, loss=1.4661 acc=0.4106\n",
      "epoch 3, train 1/100, loss=1.8146 acc=0.3067\n",
      "epoch 3, train 100/100, loss=1.5077 acc=0.3067\n",
      "epoch 3, val, loss=1.3767 acc=0.4407\n",
      "epoch 4, train 1/100, loss=1.6395 acc=0.3200\n",
      "epoch 4, train 100/100, loss=1.6156 acc=0.3333\n",
      "epoch 4, val, loss=1.3271 acc=0.4650\n",
      "epoch 5, train 1/100, loss=1.6648 acc=0.2933\n",
      "epoch 5, train 100/100, loss=1.6426 acc=0.3867\n",
      "epoch 5, val, loss=1.3222 acc=0.4531\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, args.max_epoch + 1):\n",
    "    if args.lr_decay:\n",
    "        lr_scheduler.step()\n",
    "    model.train()\n",
    "    \n",
    "    tl = Averager()\n",
    "    ta = Averager()\n",
    "\n",
    "    label = torch.arange(args.way).repeat(args.query)\n",
    "    if torch.cuda.is_available():\n",
    "        label = label.type(torch.cuda.LongTensor)\n",
    "    else:\n",
    "        label = label.type(torch.LongTensor)\n",
    "\n",
    "    for i, batch in enumerate(train_loader, 1):\n",
    "        if torch.cuda.is_available():\n",
    "            data, _ = [_.cuda() for _ in batch]\n",
    "        else:\n",
    "            data = batch[0]\n",
    "        p = args.shot * args.way\n",
    "        data_shot, data_query = data[:p], data[p:]\n",
    "        logits = model(data_shot, data_query)\n",
    "        loss = F.cross_entropy(logits, label)\n",
    "        acc = count_acc(logits, label)\n",
    "        if (i == 1) or (i == len(train_loader)): \n",
    "            print(\"epoch {}, train {}/{}, loss={:.4f} acc={:.4f}\".format(epoch, i, len(train_loader), loss.item(), acc))\n",
    "        \n",
    "        tl.add(loss.item())\n",
    "        ta.add(acc)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "    \n",
    "    tl = tl.item()\n",
    "    ta = ta.item()\n",
    "\n",
    "    model.eval()\n",
    "\n",
    "    vl = Averager()\n",
    "    va = Averager()\n",
    "\n",
    "    label = torch.arange(args.validation_way).repeat(args.query)\n",
    "    if torch.cuda.is_available():\n",
    "        label = label.type(torch.cuda.LongTensor)\n",
    "    else:\n",
    "        label = label.type(torch.LongTensor)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for i, batch in enumerate(val_loader, 1):\n",
    "            if torch.cuda.is_available():\n",
    "                data, _ = [_.cuda() for _ in batch]\n",
    "            else:\n",
    "                data = batch[0]\n",
    "            p = args.shot * args.validation_way\n",
    "            data_shot, data_query = data[:p], data[p:]\n",
    "            logits = model(data_shot, data_query)\n",
    "            loss = F.cross_entropy(logits, label)\n",
    "            acc = count_acc(logits, label)\n",
    "\n",
    "            vl.add(loss.item())\n",
    "            va.add(acc)\n",
    "\n",
    "    vl = vl.item()\n",
    "    va = va.item()\n",
    "    print(\"epoch {}, val, loss={:.4f} acc={:.4f}\".format(epoch, vl, va))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zJGSuTuEm89j"
   },
   "source": [
    "#### Testing function\n",
    "\n",
    "Once the training is complete, it's time to see model's performance on the test split."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F2CheVhrpB9x"
   },
   "source": [
    "First, let's create test dataloader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "l_mN8kGzpKfZ"
   },
   "outputs": [],
   "source": [
    "test_set = CUB(\"test\")\n",
    "test_sampler = CategoriesSampler(test_set.label, 1000, args.validation_way, args.shot + args.query)\n",
    "test_loader = DataLoader(test_set, batch_sampler=test_sampler, num_workers=8, pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "K7IEv3rGSWV_"
   },
   "outputs": [],
   "source": [
    "def compute_confidence_interval(data):\n",
    "    \"\"\"\n",
    "    Compute 95% confidence interval\n",
    "    :param data: An array of mean accuracy (or mAP) across a number of sampled episodes.\n",
    "    :return: the 95% confidence interval for this data.\n",
    "    \"\"\"\n",
    "    a = 1.0 * np.array(data)\n",
    "    m = np.mean(a)\n",
    "    std = np.std(a)\n",
    "    pm = 1.96 * (std / np.sqrt(len(a)))\n",
    "    return m, pm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "x5ysZsZbpWbx",
    "outputId": "47da73b3-c933-46d8-f8c0-a7c5bfe7fd27"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Acc 0.3999 + 0.0061\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "\n",
    "ave_acc = Averager()\n",
    "test_acc_record = np.zeros((1000,))\n",
    "\n",
    "label = torch.arange(args.validation_way).repeat(args.query)\n",
    "if torch.cuda.is_available():\n",
    "    label = label.type(torch.cuda.LongTensor)\n",
    "else:\n",
    "    label = label.type(torch.LongTensor)\n",
    "\n",
    "# Testing loop\n",
    "for i, batch in enumerate(test_loader, 1):\n",
    "    if torch.cuda.is_available():\n",
    "        data, _ = [_.cuda() for _ in batch]\n",
    "    else:\n",
    "        data = batch[0]\n",
    "    k = args.validation_way * args.shot\n",
    "    data_shot, data_query = data[:k], data[k:]\n",
    "\n",
    "    logits = model(data_shot, data_query)\n",
    "    acc = count_acc(logits, label)\n",
    "    ave_acc.add(acc)\n",
    "    test_acc_record[i - 1] = acc\n",
    "\n",
    "m, pm = compute_confidence_interval(test_acc_record)\n",
    "print(\"Test Acc {:.4f} + {:.4f}\".format(m, pm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "odWSkswZyCCo"
   },
   "source": [
    "As mentioned when defining `ProtoNet`, if `args.hyperbolic` is True, the model will be hyperbolic, Euclidean otherwise. To compare the performance of ProtoNet in hyperbolic and Euclidean manifolds, we train both of them for the same number of epochs. When training both models for $5$ epochs, the test accuracy of hyperbolic ProtoNet is around $39.99%$, while Euclidean ProtoNet results in an accuracy of $17.67%$. The paper also comes to a similar conclusion too. Based on the results provided in the paper, when training hyperbolic and Euclidean ProtoNet for $50$ epochs, the Euclidean version results in $51.31%$, while the hyperbolic one results in $64.02%$, which outperforms Euclidean one by more than $10%$."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
